Version:  2.0.40 2.2.26 2.4.37 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19

Linux/drivers/scsi/pmcraid.c

  1 /*
  2  * pmcraid.c -- driver for PMC Sierra MaxRAID controller adapters
  3  *
  4  * Written By: Anil Ravindranath<anil_ravindranath@pmc-sierra.com>
  5  *             PMC-Sierra Inc
  6  *
  7  * Copyright (C) 2008, 2009 PMC Sierra Inc
  8  *
  9  * This program is free software; you can redistribute it and/or modify
 10  * it under the terms of the GNU General Public License as published by
 11  * the Free Software Foundation; either version 2 of the License, or
 12  * (at your option) any later version.
 13  *
 14  * This program is distributed in the hope that it will be useful,
 15  * but WITHOUT ANY WARRANTY; without even the implied warranty of
 16  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 17  * GNU General Public License for more details.
 18  *
 19  * You should have received a copy of the GNU General Public License
 20  * along with this program; if not, write to the Free Software
 21  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307,
 22  * USA
 23  *
 24  */
 25 #include <linux/fs.h>
 26 #include <linux/init.h>
 27 #include <linux/types.h>
 28 #include <linux/errno.h>
 29 #include <linux/kernel.h>
 30 #include <linux/ioport.h>
 31 #include <linux/delay.h>
 32 #include <linux/pci.h>
 33 #include <linux/wait.h>
 34 #include <linux/spinlock.h>
 35 #include <linux/sched.h>
 36 #include <linux/interrupt.h>
 37 #include <linux/blkdev.h>
 38 #include <linux/firmware.h>
 39 #include <linux/module.h>
 40 #include <linux/moduleparam.h>
 41 #include <linux/hdreg.h>
 42 #include <linux/io.h>
 43 #include <linux/slab.h>
 44 #include <asm/irq.h>
 45 #include <asm/processor.h>
 46 #include <linux/libata.h>
 47 #include <linux/mutex.h>
 48 #include <scsi/scsi.h>
 49 #include <scsi/scsi_host.h>
 50 #include <scsi/scsi_device.h>
 51 #include <scsi/scsi_tcq.h>
 52 #include <scsi/scsi_eh.h>
 53 #include <scsi/scsi_cmnd.h>
 54 #include <scsi/scsicam.h>
 55 
 56 #include "pmcraid.h"
 57 
 58 /*
 59  *   Module configuration parameters
 60  */
 61 static unsigned int pmcraid_debug_log;
 62 static unsigned int pmcraid_disable_aen;
 63 static unsigned int pmcraid_log_level = IOASC_LOG_LEVEL_MUST;
 64 static unsigned int pmcraid_enable_msix;
 65 
 66 /*
 67  * Data structures to support multiple adapters by the LLD.
 68  * pmcraid_adapter_count - count of configured adapters
 69  */
 70 static atomic_t pmcraid_adapter_count = ATOMIC_INIT(0);
 71 
 72 /*
 73  * Supporting user-level control interface through IOCTL commands.
 74  * pmcraid_major - major number to use
 75  * pmcraid_minor - minor number(s) to use
 76  */
 77 static unsigned int pmcraid_major;
 78 static struct class *pmcraid_class;
 79 DECLARE_BITMAP(pmcraid_minor, PMCRAID_MAX_ADAPTERS);
 80 
 81 /*
 82  * Module parameters
 83  */
 84 MODULE_AUTHOR("Anil Ravindranath<anil_ravindranath@pmc-sierra.com>");
 85 MODULE_DESCRIPTION("PMC Sierra MaxRAID Controller Driver");
 86 MODULE_LICENSE("GPL");
 87 MODULE_VERSION(PMCRAID_DRIVER_VERSION);
 88 
 89 module_param_named(log_level, pmcraid_log_level, uint, (S_IRUGO | S_IWUSR));
 90 MODULE_PARM_DESC(log_level,
 91                  "Enables firmware error code logging, default :1 high-severity"
 92                  " errors, 2: all errors including high-severity errors,"
 93                  " 0: disables logging");
 94 
 95 module_param_named(debug, pmcraid_debug_log, uint, (S_IRUGO | S_IWUSR));
 96 MODULE_PARM_DESC(debug,
 97                  "Enable driver verbose message logging. Set 1 to enable."
 98                  "(default: 0)");
 99 
100 module_param_named(disable_aen, pmcraid_disable_aen, uint, (S_IRUGO | S_IWUSR));
101 MODULE_PARM_DESC(disable_aen,
102                  "Disable driver aen notifications to apps. Set 1 to disable."
103                  "(default: 0)");
104 
105 /* chip specific constants for PMC MaxRAID controllers (same for
106  * 0x5220 and 0x8010
107  */
108 static struct pmcraid_chip_details pmcraid_chip_cfg[] = {
109         {
110          .ioastatus = 0x0,
111          .ioarrin = 0x00040,
112          .mailbox = 0x7FC30,
113          .global_intr_mask = 0x00034,
114          .ioa_host_intr = 0x0009C,
115          .ioa_host_intr_clr = 0x000A0,
116          .ioa_host_msix_intr = 0x7FC40,
117          .ioa_host_mask = 0x7FC28,
118          .ioa_host_mask_clr = 0x7FC28,
119          .host_ioa_intr = 0x00020,
120          .host_ioa_intr_clr = 0x00020,
121          .transop_timeout = 300
122          }
123 };
124 
125 /*
126  * PCI device ids supported by pmcraid driver
127  */
128 static struct pci_device_id pmcraid_pci_table[] = {
129         { PCI_DEVICE(PCI_VENDOR_ID_PMC, PCI_DEVICE_ID_PMC_MAXRAID),
130           0, 0, (kernel_ulong_t)&pmcraid_chip_cfg[0]
131         },
132         {}
133 };
134 
135 MODULE_DEVICE_TABLE(pci, pmcraid_pci_table);
136 
137 
138 
139 /**
140  * pmcraid_slave_alloc - Prepare for commands to a device
141  * @scsi_dev: scsi device struct
142  *
143  * This function is called by mid-layer prior to sending any command to the new
144  * device. Stores resource entry details of the device in scsi_device struct.
145  * Queuecommand uses the resource handle and other details to fill up IOARCB
146  * while sending commands to the device.
147  *
148  * Return value:
149  *        0 on success / -ENXIO if device does not exist
150  */
151 static int pmcraid_slave_alloc(struct scsi_device *scsi_dev)
152 {
153         struct pmcraid_resource_entry *temp, *res = NULL;
154         struct pmcraid_instance *pinstance;
155         u8 target, bus, lun;
156         unsigned long lock_flags;
157         int rc = -ENXIO;
158         u16 fw_version;
159 
160         pinstance = shost_priv(scsi_dev->host);
161 
162         fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
163 
164         /* Driver exposes VSET and GSCSI resources only; all other device types
165          * are not exposed. Resource list is synchronized using resource lock
166          * so any traversal or modifications to the list should be done inside
167          * this lock
168          */
169         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
170         list_for_each_entry(temp, &pinstance->used_res_q, queue) {
171 
172                 /* do not expose VSETs with order-ids > MAX_VSET_TARGETS */
173                 if (RES_IS_VSET(temp->cfg_entry)) {
174                         if (fw_version <= PMCRAID_FW_VERSION_1)
175                                 target = temp->cfg_entry.unique_flags1;
176                         else
177                                 target = temp->cfg_entry.array_id & 0xFF;
178 
179                         if (target > PMCRAID_MAX_VSET_TARGETS)
180                                 continue;
181                         bus = PMCRAID_VSET_BUS_ID;
182                         lun = 0;
183                 } else if (RES_IS_GSCSI(temp->cfg_entry)) {
184                         target = RES_TARGET(temp->cfg_entry.resource_address);
185                         bus = PMCRAID_PHYS_BUS_ID;
186                         lun = RES_LUN(temp->cfg_entry.resource_address);
187                 } else {
188                         continue;
189                 }
190 
191                 if (bus == scsi_dev->channel &&
192                     target == scsi_dev->id &&
193                     lun == scsi_dev->lun) {
194                         res = temp;
195                         break;
196                 }
197         }
198 
199         if (res) {
200                 res->scsi_dev = scsi_dev;
201                 scsi_dev->hostdata = res;
202                 res->change_detected = 0;
203                 atomic_set(&res->read_failures, 0);
204                 atomic_set(&res->write_failures, 0);
205                 rc = 0;
206         }
207         spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
208         return rc;
209 }
210 
211 /**
212  * pmcraid_slave_configure - Configures a SCSI device
213  * @scsi_dev: scsi device struct
214  *
215  * This function is executed by SCSI mid layer just after a device is first
216  * scanned (i.e. it has responded to an INQUIRY). For VSET resources, the
217  * timeout value (default 30s) will be over-written to a higher value (60s)
218  * and max_sectors value will be over-written to 512. It also sets queue depth
219  * to host->cmd_per_lun value
220  *
221  * Return value:
222  *        0 on success
223  */
224 static int pmcraid_slave_configure(struct scsi_device *scsi_dev)
225 {
226         struct pmcraid_resource_entry *res = scsi_dev->hostdata;
227 
228         if (!res)
229                 return 0;
230 
231         /* LLD exposes VSETs and Enclosure devices only */
232         if (RES_IS_GSCSI(res->cfg_entry) &&
233             scsi_dev->type != TYPE_ENCLOSURE)
234                 return -ENXIO;
235 
236         pmcraid_info("configuring %x:%x:%x:%x\n",
237                      scsi_dev->host->unique_id,
238                      scsi_dev->channel,
239                      scsi_dev->id,
240                      (u8)scsi_dev->lun);
241 
242         if (RES_IS_GSCSI(res->cfg_entry)) {
243                 scsi_dev->allow_restart = 1;
244         } else if (RES_IS_VSET(res->cfg_entry)) {
245                 scsi_dev->allow_restart = 1;
246                 blk_queue_rq_timeout(scsi_dev->request_queue,
247                                      PMCRAID_VSET_IO_TIMEOUT);
248                 blk_queue_max_hw_sectors(scsi_dev->request_queue,
249                                       PMCRAID_VSET_MAX_SECTORS);
250         }
251 
252         /*
253          * We never want to report TCQ support for these types of devices.
254          */
255         if (!RES_IS_GSCSI(res->cfg_entry) && !RES_IS_VSET(res->cfg_entry))
256                 scsi_dev->tagged_supported = 0;
257 
258         return 0;
259 }
260 
261 /**
262  * pmcraid_slave_destroy - Unconfigure a SCSI device before removing it
263  *
264  * @scsi_dev: scsi device struct
265  *
266  * This is called by mid-layer before removing a device. Pointer assignments
267  * done in pmcraid_slave_alloc will be reset to NULL here.
268  *
269  * Return value
270  *   none
271  */
272 static void pmcraid_slave_destroy(struct scsi_device *scsi_dev)
273 {
274         struct pmcraid_resource_entry *res;
275 
276         res = (struct pmcraid_resource_entry *)scsi_dev->hostdata;
277 
278         if (res)
279                 res->scsi_dev = NULL;
280 
281         scsi_dev->hostdata = NULL;
282 }
283 
284 /**
285  * pmcraid_change_queue_depth - Change the device's queue depth
286  * @scsi_dev: scsi device struct
287  * @depth: depth to set
288  *
289  * Return value
290  *      actual depth set
291  */
292 static int pmcraid_change_queue_depth(struct scsi_device *scsi_dev, int depth)
293 {
294         if (depth > PMCRAID_MAX_CMD_PER_LUN)
295                 depth = PMCRAID_MAX_CMD_PER_LUN;
296         return scsi_change_queue_depth(scsi_dev, depth);
297 }
298 
299 /**
300  * pmcraid_init_cmdblk - initializes a command block
301  *
302  * @cmd: pointer to struct pmcraid_cmd to be initialized
303  * @index: if >=0 first time initialization; otherwise reinitialization
304  *
305  * Return Value
306  *       None
307  */
308 void pmcraid_init_cmdblk(struct pmcraid_cmd *cmd, int index)
309 {
310         struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
311         dma_addr_t dma_addr = cmd->ioa_cb_bus_addr;
312 
313         if (index >= 0) {
314                 /* first time initialization (called from  probe) */
315                 u32 ioasa_offset =
316                         offsetof(struct pmcraid_control_block, ioasa);
317 
318                 cmd->index = index;
319                 ioarcb->response_handle = cpu_to_le32(index << 2);
320                 ioarcb->ioarcb_bus_addr = cpu_to_le64(dma_addr);
321                 ioarcb->ioasa_bus_addr = cpu_to_le64(dma_addr + ioasa_offset);
322                 ioarcb->ioasa_len = cpu_to_le16(sizeof(struct pmcraid_ioasa));
323         } else {
324                 /* re-initialization of various lengths, called once command is
325                  * processed by IOA
326                  */
327                 memset(&cmd->ioa_cb->ioarcb.cdb, 0, PMCRAID_MAX_CDB_LEN);
328                 ioarcb->hrrq_id = 0;
329                 ioarcb->request_flags0 = 0;
330                 ioarcb->request_flags1 = 0;
331                 ioarcb->cmd_timeout = 0;
332                 ioarcb->ioarcb_bus_addr &= (~0x1FULL);
333                 ioarcb->ioadl_bus_addr = 0;
334                 ioarcb->ioadl_length = 0;
335                 ioarcb->data_transfer_length = 0;
336                 ioarcb->add_cmd_param_length = 0;
337                 ioarcb->add_cmd_param_offset = 0;
338                 cmd->ioa_cb->ioasa.ioasc = 0;
339                 cmd->ioa_cb->ioasa.residual_data_length = 0;
340                 cmd->time_left = 0;
341         }
342 
343         cmd->cmd_done = NULL;
344         cmd->scsi_cmd = NULL;
345         cmd->release = 0;
346         cmd->completion_req = 0;
347         cmd->sense_buffer = 0;
348         cmd->sense_buffer_dma = 0;
349         cmd->dma_handle = 0;
350         init_timer(&cmd->timer);
351 }
352 
353 /**
354  * pmcraid_reinit_cmdblk - reinitialize a command block
355  *
356  * @cmd: pointer to struct pmcraid_cmd to be reinitialized
357  *
358  * Return Value
359  *       None
360  */
361 static void pmcraid_reinit_cmdblk(struct pmcraid_cmd *cmd)
362 {
363         pmcraid_init_cmdblk(cmd, -1);
364 }
365 
366 /**
367  * pmcraid_get_free_cmd - get a free cmd block from command block pool
368  * @pinstance: adapter instance structure
369  *
370  * Return Value:
371  *      returns pointer to cmd block or NULL if no blocks are available
372  */
373 static struct pmcraid_cmd *pmcraid_get_free_cmd(
374         struct pmcraid_instance *pinstance
375 )
376 {
377         struct pmcraid_cmd *cmd = NULL;
378         unsigned long lock_flags;
379 
380         /* free cmd block list is protected by free_pool_lock */
381         spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
382 
383         if (!list_empty(&pinstance->free_cmd_pool)) {
384                 cmd = list_entry(pinstance->free_cmd_pool.next,
385                                  struct pmcraid_cmd, free_list);
386                 list_del(&cmd->free_list);
387         }
388         spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
389 
390         /* Initialize the command block before giving it the caller */
391         if (cmd != NULL)
392                 pmcraid_reinit_cmdblk(cmd);
393         return cmd;
394 }
395 
396 /**
397  * pmcraid_return_cmd - return a completed command block back into free pool
398  * @cmd: pointer to the command block
399  *
400  * Return Value:
401  *      nothing
402  */
403 void pmcraid_return_cmd(struct pmcraid_cmd *cmd)
404 {
405         struct pmcraid_instance *pinstance = cmd->drv_inst;
406         unsigned long lock_flags;
407 
408         spin_lock_irqsave(&pinstance->free_pool_lock, lock_flags);
409         list_add_tail(&cmd->free_list, &pinstance->free_cmd_pool);
410         spin_unlock_irqrestore(&pinstance->free_pool_lock, lock_flags);
411 }
412 
413 /**
414  * pmcraid_read_interrupts -  reads IOA interrupts
415  *
416  * @pinstance: pointer to adapter instance structure
417  *
418  * Return value
419  *       interrupts read from IOA
420  */
421 static u32 pmcraid_read_interrupts(struct pmcraid_instance *pinstance)
422 {
423         return (pinstance->interrupt_mode) ?
424                 ioread32(pinstance->int_regs.ioa_host_msix_interrupt_reg) :
425                 ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
426 }
427 
428 /**
429  * pmcraid_disable_interrupts - Masks and clears all specified interrupts
430  *
431  * @pinstance: pointer to per adapter instance structure
432  * @intrs: interrupts to disable
433  *
434  * Return Value
435  *       None
436  */
437 static void pmcraid_disable_interrupts(
438         struct pmcraid_instance *pinstance,
439         u32 intrs
440 )
441 {
442         u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
443         u32 nmask = gmask | GLOBAL_INTERRUPT_MASK;
444 
445         iowrite32(intrs, pinstance->int_regs.ioa_host_interrupt_clr_reg);
446         iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
447         ioread32(pinstance->int_regs.global_interrupt_mask_reg);
448 
449         if (!pinstance->interrupt_mode) {
450                 iowrite32(intrs,
451                         pinstance->int_regs.ioa_host_interrupt_mask_reg);
452                 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
453         }
454 }
455 
456 /**
457  * pmcraid_enable_interrupts - Enables specified interrupts
458  *
459  * @pinstance: pointer to per adapter instance structure
460  * @intr: interrupts to enable
461  *
462  * Return Value
463  *       None
464  */
465 static void pmcraid_enable_interrupts(
466         struct pmcraid_instance *pinstance,
467         u32 intrs
468 )
469 {
470         u32 gmask = ioread32(pinstance->int_regs.global_interrupt_mask_reg);
471         u32 nmask = gmask & (~GLOBAL_INTERRUPT_MASK);
472 
473         iowrite32(nmask, pinstance->int_regs.global_interrupt_mask_reg);
474 
475         if (!pinstance->interrupt_mode) {
476                 iowrite32(~intrs,
477                          pinstance->int_regs.ioa_host_interrupt_mask_reg);
478                 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
479         }
480 
481         pmcraid_info("enabled interrupts global mask = %x intr_mask = %x\n",
482                 ioread32(pinstance->int_regs.global_interrupt_mask_reg),
483                 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg));
484 }
485 
486 /**
487  * pmcraid_clr_trans_op - clear trans to op interrupt
488  *
489  * @pinstance: pointer to per adapter instance structure
490  *
491  * Return Value
492  *       None
493  */
494 static void pmcraid_clr_trans_op(
495         struct pmcraid_instance *pinstance
496 )
497 {
498         unsigned long lock_flags;
499 
500         if (!pinstance->interrupt_mode) {
501                 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
502                         pinstance->int_regs.ioa_host_interrupt_mask_reg);
503                 ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
504                 iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
505                         pinstance->int_regs.ioa_host_interrupt_clr_reg);
506                 ioread32(pinstance->int_regs.ioa_host_interrupt_clr_reg);
507         }
508 
509         if (pinstance->reset_cmd != NULL) {
510                 del_timer(&pinstance->reset_cmd->timer);
511                 spin_lock_irqsave(
512                         pinstance->host->host_lock, lock_flags);
513                 pinstance->reset_cmd->cmd_done(pinstance->reset_cmd);
514                 spin_unlock_irqrestore(
515                         pinstance->host->host_lock, lock_flags);
516         }
517 }
518 
519 /**
520  * pmcraid_reset_type - Determine the required reset type
521  * @pinstance: pointer to adapter instance structure
522  *
523  * IOA requires hard reset if any of the following conditions is true.
524  * 1. If HRRQ valid interrupt is not masked
525  * 2. IOA reset alert doorbell is set
526  * 3. If there are any error interrupts
527  */
528 static void pmcraid_reset_type(struct pmcraid_instance *pinstance)
529 {
530         u32 mask;
531         u32 intrs;
532         u32 alerts;
533 
534         mask = ioread32(pinstance->int_regs.ioa_host_interrupt_mask_reg);
535         intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
536         alerts = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
537 
538         if ((mask & INTRS_HRRQ_VALID) == 0 ||
539             (alerts & DOORBELL_IOA_RESET_ALERT) ||
540             (intrs & PMCRAID_ERROR_INTERRUPTS)) {
541                 pmcraid_info("IOA requires hard reset\n");
542                 pinstance->ioa_hard_reset = 1;
543         }
544 
545         /* If unit check is active, trigger the dump */
546         if (intrs & INTRS_IOA_UNIT_CHECK)
547                 pinstance->ioa_unit_check = 1;
548 }
549 
550 /**
551  * pmcraid_bist_done - completion function for PCI BIST
552  * @cmd: pointer to reset command
553  * Return Value
554  *      none
555  */
556 
557 static void pmcraid_ioa_reset(struct pmcraid_cmd *);
558 
559 static void pmcraid_bist_done(struct pmcraid_cmd *cmd)
560 {
561         struct pmcraid_instance *pinstance = cmd->drv_inst;
562         unsigned long lock_flags;
563         int rc;
564         u16 pci_reg;
565 
566         rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
567 
568         /* If PCI config space can't be accessed wait for another two secs */
569         if ((rc != PCIBIOS_SUCCESSFUL || (!(pci_reg & PCI_COMMAND_MEMORY))) &&
570             cmd->time_left > 0) {
571                 pmcraid_info("BIST not complete, waiting another 2 secs\n");
572                 cmd->timer.expires = jiffies + cmd->time_left;
573                 cmd->time_left = 0;
574                 cmd->timer.data = (unsigned long)cmd;
575                 cmd->timer.function =
576                         (void (*)(unsigned long))pmcraid_bist_done;
577                 add_timer(&cmd->timer);
578         } else {
579                 cmd->time_left = 0;
580                 pmcraid_info("BIST is complete, proceeding with reset\n");
581                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
582                 pmcraid_ioa_reset(cmd);
583                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
584         }
585 }
586 
587 /**
588  * pmcraid_start_bist - starts BIST
589  * @cmd: pointer to reset cmd
590  * Return Value
591  *   none
592  */
593 static void pmcraid_start_bist(struct pmcraid_cmd *cmd)
594 {
595         struct pmcraid_instance *pinstance = cmd->drv_inst;
596         u32 doorbells, intrs;
597 
598         /* proceed with bist and wait for 2 seconds */
599         iowrite32(DOORBELL_IOA_START_BIST,
600                 pinstance->int_regs.host_ioa_interrupt_reg);
601         doorbells = ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
602         intrs = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
603         pmcraid_info("doorbells after start bist: %x intrs: %x\n",
604                       doorbells, intrs);
605 
606         cmd->time_left = msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
607         cmd->timer.data = (unsigned long)cmd;
608         cmd->timer.expires = jiffies + msecs_to_jiffies(PMCRAID_BIST_TIMEOUT);
609         cmd->timer.function = (void (*)(unsigned long))pmcraid_bist_done;
610         add_timer(&cmd->timer);
611 }
612 
613 /**
614  * pmcraid_reset_alert_done - completion routine for reset_alert
615  * @cmd: pointer to command block used in reset sequence
616  * Return value
617  *  None
618  */
619 static void pmcraid_reset_alert_done(struct pmcraid_cmd *cmd)
620 {
621         struct pmcraid_instance *pinstance = cmd->drv_inst;
622         u32 status = ioread32(pinstance->ioa_status);
623         unsigned long lock_flags;
624 
625         /* if the critical operation in progress bit is set or the wait times
626          * out, invoke reset engine to proceed with hard reset. If there is
627          * some more time to wait, restart the timer
628          */
629         if (((status & INTRS_CRITICAL_OP_IN_PROGRESS) == 0) ||
630             cmd->time_left <= 0) {
631                 pmcraid_info("critical op is reset proceeding with reset\n");
632                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
633                 pmcraid_ioa_reset(cmd);
634                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
635         } else {
636                 pmcraid_info("critical op is not yet reset waiting again\n");
637                 /* restart timer if some more time is available to wait */
638                 cmd->time_left -= PMCRAID_CHECK_FOR_RESET_TIMEOUT;
639                 cmd->timer.data = (unsigned long)cmd;
640                 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
641                 cmd->timer.function =
642                         (void (*)(unsigned long))pmcraid_reset_alert_done;
643                 add_timer(&cmd->timer);
644         }
645 }
646 
647 /**
648  * pmcraid_reset_alert - alerts IOA for a possible reset
649  * @cmd : command block to be used for reset sequence.
650  *
651  * Return Value
652  *      returns 0 if pci config-space is accessible and RESET_DOORBELL is
653  *      successfully written to IOA. Returns non-zero in case pci_config_space
654  *      is not accessible
655  */
656 static void pmcraid_notify_ioastate(struct pmcraid_instance *, u32);
657 static void pmcraid_reset_alert(struct pmcraid_cmd *cmd)
658 {
659         struct pmcraid_instance *pinstance = cmd->drv_inst;
660         u32 doorbells;
661         int rc;
662         u16 pci_reg;
663 
664         /* If we are able to access IOA PCI config space, alert IOA that we are
665          * going to reset it soon. This enables IOA to preserv persistent error
666          * data if any. In case memory space is not accessible, proceed with
667          * BIST or slot_reset
668          */
669         rc = pci_read_config_word(pinstance->pdev, PCI_COMMAND, &pci_reg);
670         if ((rc == PCIBIOS_SUCCESSFUL) && (pci_reg & PCI_COMMAND_MEMORY)) {
671 
672                 /* wait for IOA permission i.e until CRITICAL_OPERATION bit is
673                  * reset IOA doesn't generate any interrupts when CRITICAL
674                  * OPERATION bit is reset. A timer is started to wait for this
675                  * bit to be reset.
676                  */
677                 cmd->time_left = PMCRAID_RESET_TIMEOUT;
678                 cmd->timer.data = (unsigned long)cmd;
679                 cmd->timer.expires = jiffies + PMCRAID_CHECK_FOR_RESET_TIMEOUT;
680                 cmd->timer.function =
681                         (void (*)(unsigned long))pmcraid_reset_alert_done;
682                 add_timer(&cmd->timer);
683 
684                 iowrite32(DOORBELL_IOA_RESET_ALERT,
685                         pinstance->int_regs.host_ioa_interrupt_reg);
686                 doorbells =
687                         ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
688                 pmcraid_info("doorbells after reset alert: %x\n", doorbells);
689         } else {
690                 pmcraid_info("PCI config is not accessible starting BIST\n");
691                 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
692                 pmcraid_start_bist(cmd);
693         }
694 }
695 
696 /**
697  * pmcraid_timeout_handler -  Timeout handler for internally generated ops
698  *
699  * @cmd : pointer to command structure, that got timedout
700  *
701  * This function blocks host requests and initiates an adapter reset.
702  *
703  * Return value:
704  *   None
705  */
706 static void pmcraid_timeout_handler(struct pmcraid_cmd *cmd)
707 {
708         struct pmcraid_instance *pinstance = cmd->drv_inst;
709         unsigned long lock_flags;
710 
711         dev_info(&pinstance->pdev->dev,
712                 "Adapter being reset due to cmd(CDB[0] = %x) timeout\n",
713                 cmd->ioa_cb->ioarcb.cdb[0]);
714 
715         /* Command timeouts result in hard reset sequence. The command that got
716          * timed out may be the one used as part of reset sequence. In this
717          * case restart reset sequence using the same command block even if
718          * reset is in progress. Otherwise fail this command and get a free
719          * command block to restart the reset sequence.
720          */
721         spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
722         if (!pinstance->ioa_reset_in_progress) {
723                 pinstance->ioa_reset_attempts = 0;
724                 cmd = pmcraid_get_free_cmd(pinstance);
725 
726                 /* If we are out of command blocks, just return here itself.
727                  * Some other command's timeout handler can do the reset job
728                  */
729                 if (cmd == NULL) {
730                         spin_unlock_irqrestore(pinstance->host->host_lock,
731                                                lock_flags);
732                         pmcraid_err("no free cmnd block for timeout handler\n");
733                         return;
734                 }
735 
736                 pinstance->reset_cmd = cmd;
737                 pinstance->ioa_reset_in_progress = 1;
738         } else {
739                 pmcraid_info("reset is already in progress\n");
740 
741                 if (pinstance->reset_cmd != cmd) {
742                         /* This command should have been given to IOA, this
743                          * command will be completed by fail_outstanding_cmds
744                          * anyway
745                          */
746                         pmcraid_err("cmd is pending but reset in progress\n");
747                 }
748 
749                 /* If this command was being used as part of the reset
750                  * sequence, set cmd_done pointer to pmcraid_ioa_reset. This
751                  * causes fail_outstanding_commands not to return the command
752                  * block back to free pool
753                  */
754                 if (cmd == pinstance->reset_cmd)
755                         cmd->cmd_done = pmcraid_ioa_reset;
756         }
757 
758         /* Notify apps of important IOA bringup/bringdown sequences */
759         if (pinstance->scn.ioa_state != PMC_DEVICE_EVENT_RESET_START &&
760             pinstance->scn.ioa_state != PMC_DEVICE_EVENT_SHUTDOWN_START)
761                 pmcraid_notify_ioastate(pinstance,
762                                         PMC_DEVICE_EVENT_RESET_START);
763 
764         pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
765         scsi_block_requests(pinstance->host);
766         pmcraid_reset_alert(cmd);
767         spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
768 }
769 
770 /**
771  * pmcraid_internal_done - completion routine for internally generated cmds
772  *
773  * @cmd: command that got response from IOA
774  *
775  * Return Value:
776  *       none
777  */
778 static void pmcraid_internal_done(struct pmcraid_cmd *cmd)
779 {
780         pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
781                      cmd->ioa_cb->ioarcb.cdb[0],
782                      le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
783 
784         /* Some of the internal commands are sent with callers blocking for the
785          * response. Same will be indicated as part of cmd->completion_req
786          * field. Response path needs to wake up any waiters waiting for cmd
787          * completion if this flag is set.
788          */
789         if (cmd->completion_req) {
790                 cmd->completion_req = 0;
791                 complete(&cmd->wait_for_completion);
792         }
793 
794         /* most of the internal commands are completed by caller itself, so
795          * no need to return the command block back to free pool until we are
796          * required to do so (e.g once done with initialization).
797          */
798         if (cmd->release) {
799                 cmd->release = 0;
800                 pmcraid_return_cmd(cmd);
801         }
802 }
803 
804 /**
805  * pmcraid_reinit_cfgtable_done - done function for cfg table reinitialization
806  *
807  * @cmd: command that got response from IOA
808  *
809  * This routine is called after driver re-reads configuration table due to a
810  * lost CCN. It returns the command block back to free pool and schedules
811  * worker thread to add/delete devices into the system.
812  *
813  * Return Value:
814  *       none
815  */
816 static void pmcraid_reinit_cfgtable_done(struct pmcraid_cmd *cmd)
817 {
818         pmcraid_info("response internal cmd CDB[0] = %x ioasc = %x\n",
819                      cmd->ioa_cb->ioarcb.cdb[0],
820                      le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
821 
822         if (cmd->release) {
823                 cmd->release = 0;
824                 pmcraid_return_cmd(cmd);
825         }
826         pmcraid_info("scheduling worker for config table reinitialization\n");
827         schedule_work(&cmd->drv_inst->worker_q);
828 }
829 
830 /**
831  * pmcraid_erp_done - Process completion of SCSI error response from device
832  * @cmd: pmcraid_command
833  *
834  * This function copies the sense buffer into the scsi_cmd struct and completes
835  * scsi_cmd by calling scsi_done function.
836  *
837  * Return value:
838  *  none
839  */
840 static void pmcraid_erp_done(struct pmcraid_cmd *cmd)
841 {
842         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
843         struct pmcraid_instance *pinstance = cmd->drv_inst;
844         u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
845 
846         if (PMCRAID_IOASC_SENSE_KEY(ioasc) > 0) {
847                 scsi_cmd->result |= (DID_ERROR << 16);
848                 scmd_printk(KERN_INFO, scsi_cmd,
849                             "command CDB[0] = %x failed with IOASC: 0x%08X\n",
850                             cmd->ioa_cb->ioarcb.cdb[0], ioasc);
851         }
852 
853         /* if we had allocated sense buffers for request sense, copy the sense
854          * release the buffers
855          */
856         if (cmd->sense_buffer != NULL) {
857                 memcpy(scsi_cmd->sense_buffer,
858                        cmd->sense_buffer,
859                        SCSI_SENSE_BUFFERSIZE);
860                 pci_free_consistent(pinstance->pdev,
861                                     SCSI_SENSE_BUFFERSIZE,
862                                     cmd->sense_buffer, cmd->sense_buffer_dma);
863                 cmd->sense_buffer = NULL;
864                 cmd->sense_buffer_dma = 0;
865         }
866 
867         scsi_dma_unmap(scsi_cmd);
868         pmcraid_return_cmd(cmd);
869         scsi_cmd->scsi_done(scsi_cmd);
870 }
871 
872 /**
873  * pmcraid_fire_command - sends an IOA command to adapter
874  *
875  * This function adds the given block into pending command list
876  * and returns without waiting
877  *
878  * @cmd : command to be sent to the device
879  *
880  * Return Value
881  *      None
882  */
883 static void _pmcraid_fire_command(struct pmcraid_cmd *cmd)
884 {
885         struct pmcraid_instance *pinstance = cmd->drv_inst;
886         unsigned long lock_flags;
887 
888         /* Add this command block to pending cmd pool. We do this prior to
889          * writting IOARCB to ioarrin because IOA might complete the command
890          * by the time we are about to add it to the list. Response handler
891          * (isr/tasklet) looks for cmd block in the pending pending list.
892          */
893         spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
894         list_add_tail(&cmd->free_list, &pinstance->pending_cmd_pool);
895         spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
896         atomic_inc(&pinstance->outstanding_cmds);
897 
898         /* driver writes lower 32-bit value of IOARCB address only */
899         mb();
900         iowrite32(le32_to_cpu(cmd->ioa_cb->ioarcb.ioarcb_bus_addr),
901                   pinstance->ioarrin);
902 }
903 
904 /**
905  * pmcraid_send_cmd - fires a command to IOA
906  *
907  * This function also sets up timeout function, and command completion
908  * function
909  *
910  * @cmd: pointer to the command block to be fired to IOA
911  * @cmd_done: command completion function, called once IOA responds
912  * @timeout: timeout to wait for this command completion
913  * @timeout_func: timeout handler
914  *
915  * Return value
916  *   none
917  */
918 static void pmcraid_send_cmd(
919         struct pmcraid_cmd *cmd,
920         void (*cmd_done) (struct pmcraid_cmd *),
921         unsigned long timeout,
922         void (*timeout_func) (struct pmcraid_cmd *)
923 )
924 {
925         /* initialize done function */
926         cmd->cmd_done = cmd_done;
927 
928         if (timeout_func) {
929                 /* setup timeout handler */
930                 cmd->timer.data = (unsigned long)cmd;
931                 cmd->timer.expires = jiffies + timeout;
932                 cmd->timer.function = (void (*)(unsigned long))timeout_func;
933                 add_timer(&cmd->timer);
934         }
935 
936         /* fire the command to IOA */
937         _pmcraid_fire_command(cmd);
938 }
939 
940 /**
941  * pmcraid_ioa_shutdown_done - completion function for IOA shutdown command
942  * @cmd: pointer to the command block used for sending IOA shutdown command
943  *
944  * Return value
945  *  None
946  */
947 static void pmcraid_ioa_shutdown_done(struct pmcraid_cmd *cmd)
948 {
949         struct pmcraid_instance *pinstance = cmd->drv_inst;
950         unsigned long lock_flags;
951 
952         spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
953         pmcraid_ioa_reset(cmd);
954         spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
955 }
956 
957 /**
958  * pmcraid_ioa_shutdown - sends SHUTDOWN command to ioa
959  *
960  * @cmd: pointer to the command block used as part of reset sequence
961  *
962  * Return Value
963  *  None
964  */
965 static void pmcraid_ioa_shutdown(struct pmcraid_cmd *cmd)
966 {
967         pmcraid_info("response for Cancel CCN CDB[0] = %x ioasc = %x\n",
968                      cmd->ioa_cb->ioarcb.cdb[0],
969                      le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
970 
971         /* Note that commands sent during reset require next command to be sent
972          * to IOA. Hence reinit the done function as well as timeout function
973          */
974         pmcraid_reinit_cmdblk(cmd);
975         cmd->ioa_cb->ioarcb.request_type = REQ_TYPE_IOACMD;
976         cmd->ioa_cb->ioarcb.resource_handle =
977                 cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
978         cmd->ioa_cb->ioarcb.cdb[0] = PMCRAID_IOA_SHUTDOWN;
979         cmd->ioa_cb->ioarcb.cdb[1] = PMCRAID_SHUTDOWN_NORMAL;
980 
981         /* fire shutdown command to hardware. */
982         pmcraid_info("firing normal shutdown command (%d) to IOA\n",
983                      le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle));
984 
985         pmcraid_notify_ioastate(cmd->drv_inst, PMC_DEVICE_EVENT_SHUTDOWN_START);
986 
987         pmcraid_send_cmd(cmd, pmcraid_ioa_shutdown_done,
988                          PMCRAID_SHUTDOWN_TIMEOUT,
989                          pmcraid_timeout_handler);
990 }
991 
992 /**
993  * pmcraid_get_fwversion_done - completion function for get_fwversion
994  *
995  * @cmd: pointer to command block used to send INQUIRY command
996  *
997  * Return Value
998  *      none
999  */
1000 static void pmcraid_querycfg(struct pmcraid_cmd *);
1001 
1002 static void pmcraid_get_fwversion_done(struct pmcraid_cmd *cmd)
1003 {
1004         struct pmcraid_instance *pinstance = cmd->drv_inst;
1005         u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1006         unsigned long lock_flags;
1007 
1008         /* configuration table entry size depends on firmware version. If fw
1009          * version is not known, it is not possible to interpret IOA config
1010          * table
1011          */
1012         if (ioasc) {
1013                 pmcraid_err("IOA Inquiry failed with %x\n", ioasc);
1014                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1015                 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1016                 pmcraid_reset_alert(cmd);
1017                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1018         } else  {
1019                 pmcraid_querycfg(cmd);
1020         }
1021 }
1022 
1023 /**
1024  * pmcraid_get_fwversion - reads firmware version information
1025  *
1026  * @cmd: pointer to command block used to send INQUIRY command
1027  *
1028  * Return Value
1029  *      none
1030  */
1031 static void pmcraid_get_fwversion(struct pmcraid_cmd *cmd)
1032 {
1033         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1034         struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
1035         struct pmcraid_instance *pinstance = cmd->drv_inst;
1036         u16 data_size = sizeof(struct pmcraid_inquiry_data);
1037 
1038         pmcraid_reinit_cmdblk(cmd);
1039         ioarcb->request_type = REQ_TYPE_SCSI;
1040         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1041         ioarcb->cdb[0] = INQUIRY;
1042         ioarcb->cdb[1] = 1;
1043         ioarcb->cdb[2] = 0xD0;
1044         ioarcb->cdb[3] = (data_size >> 8) & 0xFF;
1045         ioarcb->cdb[4] = data_size & 0xFF;
1046 
1047         /* Since entire inquiry data it can be part of IOARCB itself
1048          */
1049         ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1050                                         offsetof(struct pmcraid_ioarcb,
1051                                                 add_data.u.ioadl[0]));
1052         ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
1053         ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
1054 
1055         ioarcb->request_flags0 |= NO_LINK_DESCS;
1056         ioarcb->data_transfer_length = cpu_to_le32(data_size);
1057         ioadl = &(ioarcb->add_data.u.ioadl[0]);
1058         ioadl->flags = IOADL_FLAGS_LAST_DESC;
1059         ioadl->address = cpu_to_le64(pinstance->inq_data_baddr);
1060         ioadl->data_len = cpu_to_le32(data_size);
1061 
1062         pmcraid_send_cmd(cmd, pmcraid_get_fwversion_done,
1063                          PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
1064 }
1065 
1066 /**
1067  * pmcraid_identify_hrrq - registers host rrq buffers with IOA
1068  * @cmd: pointer to command block to be used for identify hrrq
1069  *
1070  * Return Value
1071  *       none
1072  */
1073 static void pmcraid_identify_hrrq(struct pmcraid_cmd *cmd)
1074 {
1075         struct pmcraid_instance *pinstance = cmd->drv_inst;
1076         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1077         int index = cmd->hrrq_index;
1078         __be64 hrrq_addr = cpu_to_be64(pinstance->hrrq_start_bus_addr[index]);
1079         u32 hrrq_size = cpu_to_be32(sizeof(u32) * PMCRAID_MAX_CMD);
1080         void (*done_function)(struct pmcraid_cmd *);
1081 
1082         pmcraid_reinit_cmdblk(cmd);
1083         cmd->hrrq_index = index + 1;
1084 
1085         if (cmd->hrrq_index < pinstance->num_hrrq) {
1086                 done_function = pmcraid_identify_hrrq;
1087         } else {
1088                 cmd->hrrq_index = 0;
1089                 done_function = pmcraid_get_fwversion;
1090         }
1091 
1092         /* Initialize ioarcb */
1093         ioarcb->request_type = REQ_TYPE_IOACMD;
1094         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1095 
1096         /* initialize the hrrq number where IOA will respond to this command */
1097         ioarcb->hrrq_id = index;
1098         ioarcb->cdb[0] = PMCRAID_IDENTIFY_HRRQ;
1099         ioarcb->cdb[1] = index;
1100 
1101         /* IOA expects 64-bit pci address to be written in B.E format
1102          * (i.e cdb[2]=MSByte..cdb[9]=LSB.
1103          */
1104         pmcraid_info("HRRQ_IDENTIFY with hrrq:ioarcb:index => %llx:%llx:%x\n",
1105                      hrrq_addr, ioarcb->ioarcb_bus_addr, index);
1106 
1107         memcpy(&(ioarcb->cdb[2]), &hrrq_addr, sizeof(hrrq_addr));
1108         memcpy(&(ioarcb->cdb[10]), &hrrq_size, sizeof(hrrq_size));
1109 
1110         /* Subsequent commands require HRRQ identification to be successful.
1111          * Note that this gets called even during reset from SCSI mid-layer
1112          * or tasklet
1113          */
1114         pmcraid_send_cmd(cmd, done_function,
1115                          PMCRAID_INTERNAL_TIMEOUT,
1116                          pmcraid_timeout_handler);
1117 }
1118 
1119 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd);
1120 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd);
1121 
1122 /**
1123  * pmcraid_send_hcam_cmd - send an initialized command block(HCAM) to IOA
1124  *
1125  * @cmd: initialized command block pointer
1126  *
1127  * Return Value
1128  *   none
1129  */
1130 static void pmcraid_send_hcam_cmd(struct pmcraid_cmd *cmd)
1131 {
1132         if (cmd->ioa_cb->ioarcb.cdb[1] == PMCRAID_HCAM_CODE_CONFIG_CHANGE)
1133                 atomic_set(&(cmd->drv_inst->ccn.ignore), 0);
1134         else
1135                 atomic_set(&(cmd->drv_inst->ldn.ignore), 0);
1136 
1137         pmcraid_send_cmd(cmd, cmd->cmd_done, 0, NULL);
1138 }
1139 
1140 /**
1141  * pmcraid_init_hcam - send an initialized command block(HCAM) to IOA
1142  *
1143  * @pinstance: pointer to adapter instance structure
1144  * @type: HCAM type
1145  *
1146  * Return Value
1147  *   pointer to initialized pmcraid_cmd structure or NULL
1148  */
1149 static struct pmcraid_cmd *pmcraid_init_hcam
1150 (
1151         struct pmcraid_instance *pinstance,
1152         u8 type
1153 )
1154 {
1155         struct pmcraid_cmd *cmd;
1156         struct pmcraid_ioarcb *ioarcb;
1157         struct pmcraid_ioadl_desc *ioadl;
1158         struct pmcraid_hostrcb *hcam;
1159         void (*cmd_done) (struct pmcraid_cmd *);
1160         dma_addr_t dma;
1161         int rcb_size;
1162 
1163         cmd = pmcraid_get_free_cmd(pinstance);
1164 
1165         if (!cmd) {
1166                 pmcraid_err("no free command blocks for hcam\n");
1167                 return cmd;
1168         }
1169 
1170         if (type == PMCRAID_HCAM_CODE_CONFIG_CHANGE) {
1171                 rcb_size = sizeof(struct pmcraid_hcam_ccn_ext);
1172                 cmd_done = pmcraid_process_ccn;
1173                 dma = pinstance->ccn.baddr + PMCRAID_AEN_HDR_SIZE;
1174                 hcam = &pinstance->ccn;
1175         } else {
1176                 rcb_size = sizeof(struct pmcraid_hcam_ldn);
1177                 cmd_done = pmcraid_process_ldn;
1178                 dma = pinstance->ldn.baddr + PMCRAID_AEN_HDR_SIZE;
1179                 hcam = &pinstance->ldn;
1180         }
1181 
1182         /* initialize command pointer used for HCAM registration */
1183         hcam->cmd = cmd;
1184 
1185         ioarcb = &cmd->ioa_cb->ioarcb;
1186         ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
1187                                         offsetof(struct pmcraid_ioarcb,
1188                                                 add_data.u.ioadl[0]));
1189         ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
1190         ioadl = ioarcb->add_data.u.ioadl;
1191 
1192         /* Initialize ioarcb */
1193         ioarcb->request_type = REQ_TYPE_HCAM;
1194         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
1195         ioarcb->cdb[0] = PMCRAID_HOST_CONTROLLED_ASYNC;
1196         ioarcb->cdb[1] = type;
1197         ioarcb->cdb[7] = (rcb_size >> 8) & 0xFF;
1198         ioarcb->cdb[8] = (rcb_size) & 0xFF;
1199 
1200         ioarcb->data_transfer_length = cpu_to_le32(rcb_size);
1201 
1202         ioadl[0].flags |= IOADL_FLAGS_READ_LAST;
1203         ioadl[0].data_len = cpu_to_le32(rcb_size);
1204         ioadl[0].address = cpu_to_le32(dma);
1205 
1206         cmd->cmd_done = cmd_done;
1207         return cmd;
1208 }
1209 
1210 /**
1211  * pmcraid_send_hcam - Send an HCAM to IOA
1212  * @pinstance: ioa config struct
1213  * @type: HCAM type
1214  *
1215  * This function will send a Host Controlled Async command to IOA.
1216  *
1217  * Return value:
1218  *      none
1219  */
1220 static void pmcraid_send_hcam(struct pmcraid_instance *pinstance, u8 type)
1221 {
1222         struct pmcraid_cmd *cmd = pmcraid_init_hcam(pinstance, type);
1223         pmcraid_send_hcam_cmd(cmd);
1224 }
1225 
1226 
1227 /**
1228  * pmcraid_prepare_cancel_cmd - prepares a command block to abort another
1229  *
1230  * @cmd: pointer to cmd that is used as cancelling command
1231  * @cmd_to_cancel: pointer to the command that needs to be cancelled
1232  */
1233 static void pmcraid_prepare_cancel_cmd(
1234         struct pmcraid_cmd *cmd,
1235         struct pmcraid_cmd *cmd_to_cancel
1236 )
1237 {
1238         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
1239         __be64 ioarcb_addr = cmd_to_cancel->ioa_cb->ioarcb.ioarcb_bus_addr;
1240 
1241         /* Get the resource handle to where the command to be aborted has been
1242          * sent.
1243          */
1244         ioarcb->resource_handle = cmd_to_cancel->ioa_cb->ioarcb.resource_handle;
1245         ioarcb->request_type = REQ_TYPE_IOACMD;
1246         memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
1247         ioarcb->cdb[0] = PMCRAID_ABORT_CMD;
1248 
1249         /* IOARCB address of the command to be cancelled is given in
1250          * cdb[2]..cdb[9] is Big-Endian format. Note that length bits in
1251          * IOARCB address are not masked.
1252          */
1253         ioarcb_addr = cpu_to_be64(ioarcb_addr);
1254         memcpy(&(ioarcb->cdb[2]), &ioarcb_addr, sizeof(ioarcb_addr));
1255 }
1256 
1257 /**
1258  * pmcraid_cancel_hcam - sends ABORT task to abort a given HCAM
1259  *
1260  * @cmd: command to be used as cancelling command
1261  * @type: HCAM type
1262  * @cmd_done: op done function for the cancelling command
1263  */
1264 static void pmcraid_cancel_hcam(
1265         struct pmcraid_cmd *cmd,
1266         u8 type,
1267         void (*cmd_done) (struct pmcraid_cmd *)
1268 )
1269 {
1270         struct pmcraid_instance *pinstance;
1271         struct pmcraid_hostrcb  *hcam;
1272 
1273         pinstance = cmd->drv_inst;
1274         hcam =  (type == PMCRAID_HCAM_CODE_LOG_DATA) ?
1275                 &pinstance->ldn : &pinstance->ccn;
1276 
1277         /* prepare for cancelling previous hcam command. If the HCAM is
1278          * currently not pending with IOA, we would have hcam->cmd as non-null
1279          */
1280         if (hcam->cmd == NULL)
1281                 return;
1282 
1283         pmcraid_prepare_cancel_cmd(cmd, hcam->cmd);
1284 
1285         /* writing to IOARRIN must be protected by host_lock, as mid-layer
1286          * schedule queuecommand while we are doing this
1287          */
1288         pmcraid_send_cmd(cmd, cmd_done,
1289                          PMCRAID_INTERNAL_TIMEOUT,
1290                          pmcraid_timeout_handler);
1291 }
1292 
1293 /**
1294  * pmcraid_cancel_ccn - cancel CCN HCAM already registered with IOA
1295  *
1296  * @cmd: command block to be used for cancelling the HCAM
1297  */
1298 static void pmcraid_cancel_ccn(struct pmcraid_cmd *cmd)
1299 {
1300         pmcraid_info("response for Cancel LDN CDB[0] = %x ioasc = %x\n",
1301                      cmd->ioa_cb->ioarcb.cdb[0],
1302                      le32_to_cpu(cmd->ioa_cb->ioasa.ioasc));
1303 
1304         pmcraid_reinit_cmdblk(cmd);
1305 
1306         pmcraid_cancel_hcam(cmd,
1307                             PMCRAID_HCAM_CODE_CONFIG_CHANGE,
1308                             pmcraid_ioa_shutdown);
1309 }
1310 
1311 /**
1312  * pmcraid_cancel_ldn - cancel LDN HCAM already registered with IOA
1313  *
1314  * @cmd: command block to be used for cancelling the HCAM
1315  */
1316 static void pmcraid_cancel_ldn(struct pmcraid_cmd *cmd)
1317 {
1318         pmcraid_cancel_hcam(cmd,
1319                             PMCRAID_HCAM_CODE_LOG_DATA,
1320                             pmcraid_cancel_ccn);
1321 }
1322 
1323 /**
1324  * pmcraid_expose_resource - check if the resource can be exposed to OS
1325  *
1326  * @fw_version: firmware version code
1327  * @cfgte: pointer to configuration table entry of the resource
1328  *
1329  * Return value:
1330  *      true if resource can be added to midlayer, false(0) otherwise
1331  */
1332 static int pmcraid_expose_resource(u16 fw_version,
1333                                    struct pmcraid_config_table_entry *cfgte)
1334 {
1335         int retval = 0;
1336 
1337         if (cfgte->resource_type == RES_TYPE_VSET) {
1338                 if (fw_version <= PMCRAID_FW_VERSION_1)
1339                         retval = ((cfgte->unique_flags1 & 0x80) == 0);
1340                 else
1341                         retval = ((cfgte->unique_flags0 & 0x80) == 0 &&
1342                                   (cfgte->unique_flags1 & 0x80) == 0);
1343 
1344         } else if (cfgte->resource_type == RES_TYPE_GSCSI)
1345                 retval = (RES_BUS(cfgte->resource_address) !=
1346                                 PMCRAID_VIRTUAL_ENCL_BUS_ID);
1347         return retval;
1348 }
1349 
1350 /* attributes supported by pmcraid_event_family */
1351 enum {
1352         PMCRAID_AEN_ATTR_UNSPEC,
1353         PMCRAID_AEN_ATTR_EVENT,
1354         __PMCRAID_AEN_ATTR_MAX,
1355 };
1356 #define PMCRAID_AEN_ATTR_MAX (__PMCRAID_AEN_ATTR_MAX - 1)
1357 
1358 /* commands supported by pmcraid_event_family */
1359 enum {
1360         PMCRAID_AEN_CMD_UNSPEC,
1361         PMCRAID_AEN_CMD_EVENT,
1362         __PMCRAID_AEN_CMD_MAX,
1363 };
1364 #define PMCRAID_AEN_CMD_MAX (__PMCRAID_AEN_CMD_MAX - 1)
1365 
1366 static struct genl_multicast_group pmcraid_mcgrps[] = {
1367         { .name = "events", /* not really used - see ID discussion below */ },
1368 };
1369 
1370 static struct genl_family pmcraid_event_family = {
1371         /*
1372          * Due to prior multicast group abuse (the code having assumed that
1373          * the family ID can be used as a multicast group ID) we need to
1374          * statically allocate a family (and thus group) ID.
1375          */
1376         .id = GENL_ID_PMCRAID,
1377         .name = "pmcraid",
1378         .version = 1,
1379         .maxattr = PMCRAID_AEN_ATTR_MAX,
1380         .mcgrps = pmcraid_mcgrps,
1381         .n_mcgrps = ARRAY_SIZE(pmcraid_mcgrps),
1382 };
1383 
1384 /**
1385  * pmcraid_netlink_init - registers pmcraid_event_family
1386  *
1387  * Return value:
1388  *      0 if the pmcraid_event_family is successfully registered
1389  *      with netlink generic, non-zero otherwise
1390  */
1391 static int pmcraid_netlink_init(void)
1392 {
1393         int result;
1394 
1395         result = genl_register_family(&pmcraid_event_family);
1396 
1397         if (result)
1398                 return result;
1399 
1400         pmcraid_info("registered NETLINK GENERIC group: %d\n",
1401                      pmcraid_event_family.id);
1402 
1403         return result;
1404 }
1405 
1406 /**
1407  * pmcraid_netlink_release - unregisters pmcraid_event_family
1408  *
1409  * Return value:
1410  *      none
1411  */
1412 static void pmcraid_netlink_release(void)
1413 {
1414         genl_unregister_family(&pmcraid_event_family);
1415 }
1416 
1417 /**
1418  * pmcraid_notify_aen - sends event msg to user space application
1419  * @pinstance: pointer to adapter instance structure
1420  * @type: HCAM type
1421  *
1422  * Return value:
1423  *      0 if success, error value in case of any failure.
1424  */
1425 static int pmcraid_notify_aen(
1426         struct pmcraid_instance *pinstance,
1427         struct pmcraid_aen_msg  *aen_msg,
1428         u32    data_size
1429 )
1430 {
1431         struct sk_buff *skb;
1432         void *msg_header;
1433         u32  total_size, nla_genl_hdr_total_size;
1434         int result;
1435 
1436         aen_msg->hostno = (pinstance->host->unique_id << 16 |
1437                            MINOR(pinstance->cdev.dev));
1438         aen_msg->length = data_size;
1439 
1440         data_size += sizeof(*aen_msg);
1441 
1442         total_size = nla_total_size(data_size);
1443         /* Add GENL_HDR to total_size */
1444         nla_genl_hdr_total_size =
1445                 (total_size + (GENL_HDRLEN +
1446                 ((struct genl_family *)&pmcraid_event_family)->hdrsize)
1447                  + NLMSG_HDRLEN);
1448         skb = genlmsg_new(nla_genl_hdr_total_size, GFP_ATOMIC);
1449 
1450 
1451         if (!skb) {
1452                 pmcraid_err("Failed to allocate aen data SKB of size: %x\n",
1453                              total_size);
1454                 return -ENOMEM;
1455         }
1456 
1457         /* add the genetlink message header */
1458         msg_header = genlmsg_put(skb, 0, 0,
1459                                  &pmcraid_event_family, 0,
1460                                  PMCRAID_AEN_CMD_EVENT);
1461         if (!msg_header) {
1462                 pmcraid_err("failed to copy command details\n");
1463                 nlmsg_free(skb);
1464                 return -ENOMEM;
1465         }
1466 
1467         result = nla_put(skb, PMCRAID_AEN_ATTR_EVENT, data_size, aen_msg);
1468 
1469         if (result) {
1470                 pmcraid_err("failed to copy AEN attribute data\n");
1471                 nlmsg_free(skb);
1472                 return -EINVAL;
1473         }
1474 
1475         /* send genetlink multicast message to notify appplications */
1476         result = genlmsg_end(skb, msg_header);
1477 
1478         if (result < 0) {
1479                 pmcraid_err("genlmsg_end failed\n");
1480                 nlmsg_free(skb);
1481                 return result;
1482         }
1483 
1484         result = genlmsg_multicast(&pmcraid_event_family, skb,
1485                                    0, 0, GFP_ATOMIC);
1486 
1487         /* If there are no listeners, genlmsg_multicast may return non-zero
1488          * value.
1489          */
1490         if (result)
1491                 pmcraid_info("error (%x) sending aen event message\n", result);
1492         return result;
1493 }
1494 
1495 /**
1496  * pmcraid_notify_ccn - notifies about CCN event msg to user space
1497  * @pinstance: pointer adapter instance structure
1498  *
1499  * Return value:
1500  *      0 if success, error value in case of any failure
1501  */
1502 static int pmcraid_notify_ccn(struct pmcraid_instance *pinstance)
1503 {
1504         return pmcraid_notify_aen(pinstance,
1505                                 pinstance->ccn.msg,
1506                                 pinstance->ccn.hcam->data_len +
1507                                 sizeof(struct pmcraid_hcam_hdr));
1508 }
1509 
1510 /**
1511  * pmcraid_notify_ldn - notifies about CCN event msg to user space
1512  * @pinstance: pointer adapter instance structure
1513  *
1514  * Return value:
1515  *      0 if success, error value in case of any failure
1516  */
1517 static int pmcraid_notify_ldn(struct pmcraid_instance *pinstance)
1518 {
1519         return pmcraid_notify_aen(pinstance,
1520                                 pinstance->ldn.msg,
1521                                 pinstance->ldn.hcam->data_len +
1522                                 sizeof(struct pmcraid_hcam_hdr));
1523 }
1524 
1525 /**
1526  * pmcraid_notify_ioastate - sends IOA state event msg to user space
1527  * @pinstance: pointer adapter instance structure
1528  * @evt: controller state event to be sent
1529  *
1530  * Return value:
1531  *      0 if success, error value in case of any failure
1532  */
1533 static void pmcraid_notify_ioastate(struct pmcraid_instance *pinstance, u32 evt)
1534 {
1535         pinstance->scn.ioa_state = evt;
1536         pmcraid_notify_aen(pinstance,
1537                           &pinstance->scn.msg,
1538                           sizeof(u32));
1539 }
1540 
1541 /**
1542  * pmcraid_handle_config_change - Handle a config change from the adapter
1543  * @pinstance: pointer to per adapter instance structure
1544  *
1545  * Return value:
1546  *  none
1547  */
1548 
1549 static void pmcraid_handle_config_change(struct pmcraid_instance *pinstance)
1550 {
1551         struct pmcraid_config_table_entry *cfg_entry;
1552         struct pmcraid_hcam_ccn *ccn_hcam;
1553         struct pmcraid_cmd *cmd;
1554         struct pmcraid_cmd *cfgcmd;
1555         struct pmcraid_resource_entry *res = NULL;
1556         unsigned long lock_flags;
1557         unsigned long host_lock_flags;
1558         u32 new_entry = 1;
1559         u32 hidden_entry = 0;
1560         u16 fw_version;
1561         int rc;
1562 
1563         ccn_hcam = (struct pmcraid_hcam_ccn *)pinstance->ccn.hcam;
1564         cfg_entry = &ccn_hcam->cfg_entry;
1565         fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
1566 
1567         pmcraid_info("CCN(%x): %x timestamp: %llx type: %x lost: %x flags: %x \
1568                  res: %x:%x:%x:%x\n",
1569                  pinstance->ccn.hcam->ilid,
1570                  pinstance->ccn.hcam->op_code,
1571                 ((pinstance->ccn.hcam->timestamp1) |
1572                 ((pinstance->ccn.hcam->timestamp2 & 0xffffffffLL) << 32)),
1573                  pinstance->ccn.hcam->notification_type,
1574                  pinstance->ccn.hcam->notification_lost,
1575                  pinstance->ccn.hcam->flags,
1576                  pinstance->host->unique_id,
1577                  RES_IS_VSET(*cfg_entry) ? PMCRAID_VSET_BUS_ID :
1578                  (RES_IS_GSCSI(*cfg_entry) ? PMCRAID_PHYS_BUS_ID :
1579                         RES_BUS(cfg_entry->resource_address)),
1580                  RES_IS_VSET(*cfg_entry) ?
1581                         (fw_version <= PMCRAID_FW_VERSION_1 ?
1582                                 cfg_entry->unique_flags1 :
1583                                         cfg_entry->array_id & 0xFF) :
1584                         RES_TARGET(cfg_entry->resource_address),
1585                  RES_LUN(cfg_entry->resource_address));
1586 
1587 
1588         /* If this HCAM indicates a lost notification, read the config table */
1589         if (pinstance->ccn.hcam->notification_lost) {
1590                 cfgcmd = pmcraid_get_free_cmd(pinstance);
1591                 if (cfgcmd) {
1592                         pmcraid_info("lost CCN, reading config table\b");
1593                         pinstance->reinit_cfg_table = 1;
1594                         pmcraid_querycfg(cfgcmd);
1595                 } else {
1596                         pmcraid_err("lost CCN, no free cmd for querycfg\n");
1597                 }
1598                 goto out_notify_apps;
1599         }
1600 
1601         /* If this resource is not going to be added to mid-layer, just notify
1602          * applications and return. If this notification is about hiding a VSET
1603          * resource, check if it was exposed already.
1604          */
1605         if (pinstance->ccn.hcam->notification_type ==
1606             NOTIFICATION_TYPE_ENTRY_CHANGED &&
1607             cfg_entry->resource_type == RES_TYPE_VSET) {
1608 
1609                 if (fw_version <= PMCRAID_FW_VERSION_1)
1610                         hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
1611                 else
1612                         hidden_entry = (cfg_entry->unique_flags1 & 0x80) != 0;
1613 
1614         } else if (!pmcraid_expose_resource(fw_version, cfg_entry)) {
1615                 goto out_notify_apps;
1616         }
1617 
1618         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
1619         list_for_each_entry(res, &pinstance->used_res_q, queue) {
1620                 rc = memcmp(&res->cfg_entry.resource_address,
1621                             &cfg_entry->resource_address,
1622                             sizeof(cfg_entry->resource_address));
1623                 if (!rc) {
1624                         new_entry = 0;
1625                         break;
1626                 }
1627         }
1628 
1629         if (new_entry) {
1630 
1631                 if (hidden_entry) {
1632                         spin_unlock_irqrestore(&pinstance->resource_lock,
1633                                                 lock_flags);
1634                         goto out_notify_apps;
1635                 }
1636 
1637                 /* If there are more number of resources than what driver can
1638                  * manage, do not notify the applications about the CCN. Just
1639                  * ignore this notifications and re-register the same HCAM
1640                  */
1641                 if (list_empty(&pinstance->free_res_q)) {
1642                         spin_unlock_irqrestore(&pinstance->resource_lock,
1643                                                 lock_flags);
1644                         pmcraid_err("too many resources attached\n");
1645                         spin_lock_irqsave(pinstance->host->host_lock,
1646                                           host_lock_flags);
1647                         pmcraid_send_hcam(pinstance,
1648                                           PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1649                         spin_unlock_irqrestore(pinstance->host->host_lock,
1650                                                host_lock_flags);
1651                         return;
1652                 }
1653 
1654                 res = list_entry(pinstance->free_res_q.next,
1655                                  struct pmcraid_resource_entry, queue);
1656 
1657                 list_del(&res->queue);
1658                 res->scsi_dev = NULL;
1659                 res->reset_progress = 0;
1660                 list_add_tail(&res->queue, &pinstance->used_res_q);
1661         }
1662 
1663         memcpy(&res->cfg_entry, cfg_entry, pinstance->config_table_entry_size);
1664 
1665         if (pinstance->ccn.hcam->notification_type ==
1666             NOTIFICATION_TYPE_ENTRY_DELETED || hidden_entry) {
1667                 if (res->scsi_dev) {
1668                         if (fw_version <= PMCRAID_FW_VERSION_1)
1669                                 res->cfg_entry.unique_flags1 &= 0x7F;
1670                         else
1671                                 res->cfg_entry.array_id &= 0xFF;
1672                         res->change_detected = RES_CHANGE_DEL;
1673                         res->cfg_entry.resource_handle =
1674                                 PMCRAID_INVALID_RES_HANDLE;
1675                         schedule_work(&pinstance->worker_q);
1676                 } else {
1677                         /* This may be one of the non-exposed resources */
1678                         list_move_tail(&res->queue, &pinstance->free_res_q);
1679                 }
1680         } else if (!res->scsi_dev) {
1681                 res->change_detected = RES_CHANGE_ADD;
1682                 schedule_work(&pinstance->worker_q);
1683         }
1684         spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
1685 
1686 out_notify_apps:
1687 
1688         /* Notify configuration changes to registered applications.*/
1689         if (!pmcraid_disable_aen)
1690                 pmcraid_notify_ccn(pinstance);
1691 
1692         cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1693         if (cmd)
1694                 pmcraid_send_hcam_cmd(cmd);
1695 }
1696 
1697 /**
1698  * pmcraid_get_error_info - return error string for an ioasc
1699  * @ioasc: ioasc code
1700  * Return Value
1701  *       none
1702  */
1703 static struct pmcraid_ioasc_error *pmcraid_get_error_info(u32 ioasc)
1704 {
1705         int i;
1706         for (i = 0; i < ARRAY_SIZE(pmcraid_ioasc_error_table); i++) {
1707                 if (pmcraid_ioasc_error_table[i].ioasc_code == ioasc)
1708                         return &pmcraid_ioasc_error_table[i];
1709         }
1710         return NULL;
1711 }
1712 
1713 /**
1714  * pmcraid_ioasc_logger - log IOASC information based user-settings
1715  * @ioasc: ioasc code
1716  * @cmd: pointer to command that resulted in 'ioasc'
1717  */
1718 void pmcraid_ioasc_logger(u32 ioasc, struct pmcraid_cmd *cmd)
1719 {
1720         struct pmcraid_ioasc_error *error_info = pmcraid_get_error_info(ioasc);
1721 
1722         if (error_info == NULL ||
1723                 cmd->drv_inst->current_log_level < error_info->log_level)
1724                 return;
1725 
1726         /* log the error string */
1727         pmcraid_err("cmd [%x] for resource %x failed with %x(%s)\n",
1728                 cmd->ioa_cb->ioarcb.cdb[0],
1729                 cmd->ioa_cb->ioarcb.resource_handle,
1730                 le32_to_cpu(ioasc), error_info->error_string);
1731 }
1732 
1733 /**
1734  * pmcraid_handle_error_log - Handle a config change (error log) from the IOA
1735  *
1736  * @pinstance: pointer to per adapter instance structure
1737  *
1738  * Return value:
1739  *  none
1740  */
1741 static void pmcraid_handle_error_log(struct pmcraid_instance *pinstance)
1742 {
1743         struct pmcraid_hcam_ldn *hcam_ldn;
1744         u32 ioasc;
1745 
1746         hcam_ldn = (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1747 
1748         pmcraid_info
1749                 ("LDN(%x): %x type: %x lost: %x flags: %x overlay id: %x\n",
1750                  pinstance->ldn.hcam->ilid,
1751                  pinstance->ldn.hcam->op_code,
1752                  pinstance->ldn.hcam->notification_type,
1753                  pinstance->ldn.hcam->notification_lost,
1754                  pinstance->ldn.hcam->flags,
1755                  pinstance->ldn.hcam->overlay_id);
1756 
1757         /* log only the errors, no need to log informational log entries */
1758         if (pinstance->ldn.hcam->notification_type !=
1759             NOTIFICATION_TYPE_ERROR_LOG)
1760                 return;
1761 
1762         if (pinstance->ldn.hcam->notification_lost ==
1763             HOSTRCB_NOTIFICATIONS_LOST)
1764                 dev_info(&pinstance->pdev->dev, "Error notifications lost\n");
1765 
1766         ioasc = le32_to_cpu(hcam_ldn->error_log.fd_ioasc);
1767 
1768         if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
1769                 ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER) {
1770                 dev_info(&pinstance->pdev->dev,
1771                         "UnitAttention due to IOA Bus Reset\n");
1772                 scsi_report_bus_reset(
1773                         pinstance->host,
1774                         RES_BUS(hcam_ldn->error_log.fd_ra));
1775         }
1776 
1777         return;
1778 }
1779 
1780 /**
1781  * pmcraid_process_ccn - Op done function for a CCN.
1782  * @cmd: pointer to command struct
1783  *
1784  * This function is the op done function for a configuration
1785  * change notification
1786  *
1787  * Return value:
1788  * none
1789  */
1790 static void pmcraid_process_ccn(struct pmcraid_cmd *cmd)
1791 {
1792         struct pmcraid_instance *pinstance = cmd->drv_inst;
1793         u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1794         unsigned long lock_flags;
1795 
1796         pinstance->ccn.cmd = NULL;
1797         pmcraid_return_cmd(cmd);
1798 
1799         /* If driver initiated IOA reset happened while this hcam was pending
1800          * with IOA, or IOA bringdown sequence is in progress, no need to
1801          * re-register the hcam
1802          */
1803         if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
1804             atomic_read(&pinstance->ccn.ignore) == 1) {
1805                 return;
1806         } else if (ioasc) {
1807                 dev_info(&pinstance->pdev->dev,
1808                         "Host RCB (CCN) failed with IOASC: 0x%08X\n", ioasc);
1809                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
1810                 pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1811                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
1812         } else {
1813                 pmcraid_handle_config_change(pinstance);
1814         }
1815 }
1816 
1817 /**
1818  * pmcraid_process_ldn - op done function for an LDN
1819  * @cmd: pointer to command block
1820  *
1821  * Return value
1822  *   none
1823  */
1824 static void pmcraid_initiate_reset(struct pmcraid_instance *);
1825 static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd);
1826 
1827 static void pmcraid_process_ldn(struct pmcraid_cmd *cmd)
1828 {
1829         struct pmcraid_instance *pinstance = cmd->drv_inst;
1830         struct pmcraid_hcam_ldn *ldn_hcam =
1831                         (struct pmcraid_hcam_ldn *)pinstance->ldn.hcam;
1832         u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
1833         u32 fd_ioasc = le32_to_cpu(ldn_hcam->error_log.fd_ioasc);
1834         unsigned long lock_flags;
1835 
1836         /* return the command block back to freepool */
1837         pinstance->ldn.cmd = NULL;
1838         pmcraid_return_cmd(cmd);
1839 
1840         /* If driver initiated IOA reset happened while this hcam was pending
1841          * with IOA, no need to re-register the hcam as reset engine will do it
1842          * once reset sequence is complete
1843          */
1844         if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
1845             atomic_read(&pinstance->ccn.ignore) == 1) {
1846                 return;
1847         } else if (!ioasc) {
1848                 pmcraid_handle_error_log(pinstance);
1849                 if (fd_ioasc == PMCRAID_IOASC_NR_IOA_RESET_REQUIRED) {
1850                         spin_lock_irqsave(pinstance->host->host_lock,
1851                                           lock_flags);
1852                         pmcraid_initiate_reset(pinstance);
1853                         spin_unlock_irqrestore(pinstance->host->host_lock,
1854                                                lock_flags);
1855                         return;
1856                 }
1857                 if (fd_ioasc == PMCRAID_IOASC_TIME_STAMP_OUT_OF_SYNC) {
1858                         pinstance->timestamp_error = 1;
1859                         pmcraid_set_timestamp(cmd);
1860                 }
1861         } else {
1862                 dev_info(&pinstance->pdev->dev,
1863                         "Host RCB(LDN) failed with IOASC: 0x%08X\n", ioasc);
1864         }
1865         /* send netlink message for HCAM notification if enabled */
1866         if (!pmcraid_disable_aen)
1867                 pmcraid_notify_ldn(pinstance);
1868 
1869         cmd = pmcraid_init_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1870         if (cmd)
1871                 pmcraid_send_hcam_cmd(cmd);
1872 }
1873 
1874 /**
1875  * pmcraid_register_hcams - register HCAMs for CCN and LDN
1876  *
1877  * @pinstance: pointer per adapter instance structure
1878  *
1879  * Return Value
1880  *   none
1881  */
1882 static void pmcraid_register_hcams(struct pmcraid_instance *pinstance)
1883 {
1884         pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_CONFIG_CHANGE);
1885         pmcraid_send_hcam(pinstance, PMCRAID_HCAM_CODE_LOG_DATA);
1886 }
1887 
1888 /**
1889  * pmcraid_unregister_hcams - cancel HCAMs registered already
1890  * @cmd: pointer to command used as part of reset sequence
1891  */
1892 static void pmcraid_unregister_hcams(struct pmcraid_cmd *cmd)
1893 {
1894         struct pmcraid_instance *pinstance = cmd->drv_inst;
1895 
1896         /* During IOA bringdown, HCAM gets fired and tasklet proceeds with
1897          * handling hcam response though it is not necessary. In order to
1898          * prevent this, set 'ignore', so that bring-down sequence doesn't
1899          * re-send any more hcams
1900          */
1901         atomic_set(&pinstance->ccn.ignore, 1);
1902         atomic_set(&pinstance->ldn.ignore, 1);
1903 
1904         /* If adapter reset was forced as part of runtime reset sequence,
1905          * start the reset sequence. Reset will be triggered even in case
1906          * IOA unit_check.
1907          */
1908         if ((pinstance->force_ioa_reset && !pinstance->ioa_bringdown) ||
1909              pinstance->ioa_unit_check) {
1910                 pinstance->force_ioa_reset = 0;
1911                 pinstance->ioa_unit_check = 0;
1912                 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
1913                 pmcraid_reset_alert(cmd);
1914                 return;
1915         }
1916 
1917         /* Driver tries to cancel HCAMs by sending ABORT TASK for each HCAM
1918          * one after the other. So CCN cancellation will be triggered by
1919          * pmcraid_cancel_ldn itself.
1920          */
1921         pmcraid_cancel_ldn(cmd);
1922 }
1923 
1924 /**
1925  * pmcraid_reset_enable_ioa - re-enable IOA after a hard reset
1926  * @pinstance: pointer to adapter instance structure
1927  * Return Value
1928  *  1 if TRANSITION_TO_OPERATIONAL is active, otherwise 0
1929  */
1930 static void pmcraid_reinit_buffers(struct pmcraid_instance *);
1931 
1932 static int pmcraid_reset_enable_ioa(struct pmcraid_instance *pinstance)
1933 {
1934         u32 intrs;
1935 
1936         pmcraid_reinit_buffers(pinstance);
1937         intrs = pmcraid_read_interrupts(pinstance);
1938 
1939         pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
1940 
1941         if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
1942                 if (!pinstance->interrupt_mode) {
1943                         iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
1944                                 pinstance->int_regs.
1945                                 ioa_host_interrupt_mask_reg);
1946                         iowrite32(INTRS_TRANSITION_TO_OPERATIONAL,
1947                                 pinstance->int_regs.ioa_host_interrupt_clr_reg);
1948                 }
1949                 return 1;
1950         } else {
1951                 return 0;
1952         }
1953 }
1954 
1955 /**
1956  * pmcraid_soft_reset - performs a soft reset and makes IOA become ready
1957  * @cmd : pointer to reset command block
1958  *
1959  * Return Value
1960  *      none
1961  */
1962 static void pmcraid_soft_reset(struct pmcraid_cmd *cmd)
1963 {
1964         struct pmcraid_instance *pinstance = cmd->drv_inst;
1965         u32 int_reg;
1966         u32 doorbell;
1967 
1968         /* There will be an interrupt when Transition to Operational bit is
1969          * set so tasklet would execute next reset task. The timeout handler
1970          * would re-initiate a reset
1971          */
1972         cmd->cmd_done = pmcraid_ioa_reset;
1973         cmd->timer.data = (unsigned long)cmd;
1974         cmd->timer.expires = jiffies +
1975                              msecs_to_jiffies(PMCRAID_TRANSOP_TIMEOUT);
1976         cmd->timer.function = (void (*)(unsigned long))pmcraid_timeout_handler;
1977 
1978         if (!timer_pending(&cmd->timer))
1979                 add_timer(&cmd->timer);
1980 
1981         /* Enable destructive diagnostics on IOA if it is not yet in
1982          * operational state
1983          */
1984         doorbell = DOORBELL_RUNTIME_RESET |
1985                    DOORBELL_ENABLE_DESTRUCTIVE_DIAGS;
1986 
1987         /* Since we do RESET_ALERT and Start BIST we have to again write
1988          * MSIX Doorbell to indicate the interrupt mode
1989          */
1990         if (pinstance->interrupt_mode) {
1991                 iowrite32(DOORBELL_INTR_MODE_MSIX,
1992                           pinstance->int_regs.host_ioa_interrupt_reg);
1993                 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
1994         }
1995 
1996         iowrite32(doorbell, pinstance->int_regs.host_ioa_interrupt_reg);
1997         ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
1998         int_reg = ioread32(pinstance->int_regs.ioa_host_interrupt_reg);
1999 
2000         pmcraid_info("Waiting for IOA to become operational %x:%x\n",
2001                      ioread32(pinstance->int_regs.host_ioa_interrupt_reg),
2002                      int_reg);
2003 }
2004 
2005 /**
2006  * pmcraid_get_dump - retrieves IOA dump in case of Unit Check interrupt
2007  *
2008  * @pinstance: pointer to adapter instance structure
2009  *
2010  * Return Value
2011  *      none
2012  */
2013 static void pmcraid_get_dump(struct pmcraid_instance *pinstance)
2014 {
2015         pmcraid_info("%s is not yet implemented\n", __func__);
2016 }
2017 
2018 /**
2019  * pmcraid_fail_outstanding_cmds - Fails all outstanding ops.
2020  * @pinstance: pointer to adapter instance structure
2021  *
2022  * This function fails all outstanding ops. If they are submitted to IOA
2023  * already, it sends cancel all messages if IOA is still accepting IOARCBs,
2024  * otherwise just completes the commands and returns the cmd blocks to free
2025  * pool.
2026  *
2027  * Return value:
2028  *       none
2029  */
2030 static void pmcraid_fail_outstanding_cmds(struct pmcraid_instance *pinstance)
2031 {
2032         struct pmcraid_cmd *cmd, *temp;
2033         unsigned long lock_flags;
2034 
2035         /* pending command list is protected by pending_pool_lock. Its
2036          * traversal must be done as within this lock
2037          */
2038         spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2039         list_for_each_entry_safe(cmd, temp, &pinstance->pending_cmd_pool,
2040                                  free_list) {
2041                 list_del(&cmd->free_list);
2042                 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
2043                                         lock_flags);
2044                 cmd->ioa_cb->ioasa.ioasc =
2045                         cpu_to_le32(PMCRAID_IOASC_IOA_WAS_RESET);
2046                 cmd->ioa_cb->ioasa.ilid =
2047                         cpu_to_be32(PMCRAID_DRIVER_ILID);
2048 
2049                 /* In case the command timer is still running */
2050                 del_timer(&cmd->timer);
2051 
2052                 /* If this is an IO command, complete it by invoking scsi_done
2053                  * function. If this is one of the internal commands other
2054                  * than pmcraid_ioa_reset and HCAM commands invoke cmd_done to
2055                  * complete it
2056                  */
2057                 if (cmd->scsi_cmd) {
2058 
2059                         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2060                         __le32 resp = cmd->ioa_cb->ioarcb.response_handle;
2061 
2062                         scsi_cmd->result |= DID_ERROR << 16;
2063 
2064                         scsi_dma_unmap(scsi_cmd);
2065                         pmcraid_return_cmd(cmd);
2066 
2067                         pmcraid_info("failing(%d) CDB[0] = %x result: %x\n",
2068                                      le32_to_cpu(resp) >> 2,
2069                                      cmd->ioa_cb->ioarcb.cdb[0],
2070                                      scsi_cmd->result);
2071                         scsi_cmd->scsi_done(scsi_cmd);
2072                 } else if (cmd->cmd_done == pmcraid_internal_done ||
2073                            cmd->cmd_done == pmcraid_erp_done) {
2074                         cmd->cmd_done(cmd);
2075                 } else if (cmd->cmd_done != pmcraid_ioa_reset &&
2076                            cmd->cmd_done != pmcraid_ioa_shutdown_done) {
2077                         pmcraid_return_cmd(cmd);
2078                 }
2079 
2080                 atomic_dec(&pinstance->outstanding_cmds);
2081                 spin_lock_irqsave(&pinstance->pending_pool_lock, lock_flags);
2082         }
2083 
2084         spin_unlock_irqrestore(&pinstance->pending_pool_lock, lock_flags);
2085 }
2086 
2087 /**
2088  * pmcraid_ioa_reset - Implementation of IOA reset logic
2089  *
2090  * @cmd: pointer to the cmd block to be used for entire reset process
2091  *
2092  * This function executes most of the steps required for IOA reset. This gets
2093  * called by user threads (modprobe/insmod/rmmod) timer, tasklet and midlayer's
2094  * 'eh_' thread. Access to variables used for controlling the reset sequence is
2095  * synchronized using host lock. Various functions called during reset process
2096  * would make use of a single command block, pointer to which is also stored in
2097  * adapter instance structure.
2098  *
2099  * Return Value
2100  *       None
2101  */
2102 static void pmcraid_ioa_reset(struct pmcraid_cmd *cmd)
2103 {
2104         struct pmcraid_instance *pinstance = cmd->drv_inst;
2105         u8 reset_complete = 0;
2106 
2107         pinstance->ioa_reset_in_progress = 1;
2108 
2109         if (pinstance->reset_cmd != cmd) {
2110                 pmcraid_err("reset is called with different command block\n");
2111                 pinstance->reset_cmd = cmd;
2112         }
2113 
2114         pmcraid_info("reset_engine: state = %d, command = %p\n",
2115                       pinstance->ioa_state, cmd);
2116 
2117         switch (pinstance->ioa_state) {
2118 
2119         case IOA_STATE_DEAD:
2120                 /* If IOA is offline, whatever may be the reset reason, just
2121                  * return. callers might be waiting on the reset wait_q, wake
2122                  * up them
2123                  */
2124                 pmcraid_err("IOA is offline no reset is possible\n");
2125                 reset_complete = 1;
2126                 break;
2127 
2128         case IOA_STATE_IN_BRINGDOWN:
2129                 /* we enter here, once ioa shutdown command is processed by IOA
2130                  * Alert IOA for a possible reset. If reset alert fails, IOA
2131                  * goes through hard-reset
2132                  */
2133                 pmcraid_disable_interrupts(pinstance, ~0);
2134                 pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2135                 pmcraid_reset_alert(cmd);
2136                 break;
2137 
2138         case IOA_STATE_UNKNOWN:
2139                 /* We may be called during probe or resume. Some pre-processing
2140                  * is required for prior to reset
2141                  */
2142                 scsi_block_requests(pinstance->host);
2143 
2144                 /* If asked to reset while IOA was processing responses or
2145                  * there are any error responses then IOA may require
2146                  * hard-reset.
2147                  */
2148                 if (pinstance->ioa_hard_reset == 0) {
2149                         if (ioread32(pinstance->ioa_status) &
2150                             INTRS_TRANSITION_TO_OPERATIONAL) {
2151                                 pmcraid_info("sticky bit set, bring-up\n");
2152                                 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2153                                 pmcraid_reinit_cmdblk(cmd);
2154                                 pmcraid_identify_hrrq(cmd);
2155                         } else {
2156                                 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2157                                 pmcraid_soft_reset(cmd);
2158                         }
2159                 } else {
2160                         /* Alert IOA of a possible reset and wait for critical
2161                          * operation in progress bit to reset
2162                          */
2163                         pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2164                         pmcraid_reset_alert(cmd);
2165                 }
2166                 break;
2167 
2168         case IOA_STATE_IN_RESET_ALERT:
2169                 /* If critical operation in progress bit is reset or wait gets
2170                  * timed out, reset proceeds with starting BIST on the IOA.
2171                  * pmcraid_ioa_hard_reset keeps a count of reset attempts. If
2172                  * they are 3 or more, reset engine marks IOA dead and returns
2173                  */
2174                 pinstance->ioa_state = IOA_STATE_IN_HARD_RESET;
2175                 pmcraid_start_bist(cmd);
2176                 break;
2177 
2178         case IOA_STATE_IN_HARD_RESET:
2179                 pinstance->ioa_reset_attempts++;
2180 
2181                 /* retry reset if we haven't reached maximum allowed limit */
2182                 if (pinstance->ioa_reset_attempts > PMCRAID_RESET_ATTEMPTS) {
2183                         pinstance->ioa_reset_attempts = 0;
2184                         pmcraid_err("IOA didn't respond marking it as dead\n");
2185                         pinstance->ioa_state = IOA_STATE_DEAD;
2186 
2187                         if (pinstance->ioa_bringdown)
2188                                 pmcraid_notify_ioastate(pinstance,
2189                                         PMC_DEVICE_EVENT_SHUTDOWN_FAILED);
2190                         else
2191                                 pmcraid_notify_ioastate(pinstance,
2192                                                 PMC_DEVICE_EVENT_RESET_FAILED);
2193                         reset_complete = 1;
2194                         break;
2195                 }
2196 
2197                 /* Once either bist or pci reset is done, restore PCI config
2198                  * space. If this fails, proceed with hard reset again
2199                  */
2200                 pci_restore_state(pinstance->pdev);
2201 
2202                 /* fail all pending commands */
2203                 pmcraid_fail_outstanding_cmds(pinstance);
2204 
2205                 /* check if unit check is active, if so extract dump */
2206                 if (pinstance->ioa_unit_check) {
2207                         pmcraid_info("unit check is active\n");
2208                         pinstance->ioa_unit_check = 0;
2209                         pmcraid_get_dump(pinstance);
2210                         pinstance->ioa_reset_attempts--;
2211                         pinstance->ioa_state = IOA_STATE_IN_RESET_ALERT;
2212                         pmcraid_reset_alert(cmd);
2213                         break;
2214                 }
2215 
2216                 /* if the reset reason is to bring-down the ioa, we might be
2217                  * done with the reset restore pci_config_space and complete
2218                  * the reset
2219                  */
2220                 if (pinstance->ioa_bringdown) {
2221                         pmcraid_info("bringing down the adapter\n");
2222                         pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2223                         pinstance->ioa_bringdown = 0;
2224                         pinstance->ioa_state = IOA_STATE_UNKNOWN;
2225                         pmcraid_notify_ioastate(pinstance,
2226                                         PMC_DEVICE_EVENT_SHUTDOWN_SUCCESS);
2227                         reset_complete = 1;
2228                 } else {
2229                         /* bring-up IOA, so proceed with soft reset
2230                          * Reinitialize hrrq_buffers and their indices also
2231                          * enable interrupts after a pci_restore_state
2232                          */
2233                         if (pmcraid_reset_enable_ioa(pinstance)) {
2234                                 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2235                                 pmcraid_info("bringing up the adapter\n");
2236                                 pmcraid_reinit_cmdblk(cmd);
2237                                 pmcraid_identify_hrrq(cmd);
2238                         } else {
2239                                 pinstance->ioa_state = IOA_STATE_IN_SOFT_RESET;
2240                                 pmcraid_soft_reset(cmd);
2241                         }
2242                 }
2243                 break;
2244 
2245         case IOA_STATE_IN_SOFT_RESET:
2246                 /* TRANSITION TO OPERATIONAL is on so start initialization
2247                  * sequence
2248                  */
2249                 pmcraid_info("In softreset proceeding with bring-up\n");
2250                 pinstance->ioa_state = IOA_STATE_IN_BRINGUP;
2251 
2252                 /* Initialization commands start with HRRQ identification. From
2253                  * now on tasklet completes most of the commands as IOA is up
2254                  * and intrs are enabled
2255                  */
2256                 pmcraid_identify_hrrq(cmd);
2257                 break;
2258 
2259         case IOA_STATE_IN_BRINGUP:
2260                 /* we are done with bringing up of IOA, change the ioa_state to
2261                  * operational and wake up any waiters
2262                  */
2263                 pinstance->ioa_state = IOA_STATE_OPERATIONAL;
2264                 reset_complete = 1;
2265                 break;
2266 
2267         case IOA_STATE_OPERATIONAL:
2268         default:
2269                 /* When IOA is operational and a reset is requested, check for
2270                  * the reset reason. If reset is to bring down IOA, unregister
2271                  * HCAMs and initiate shutdown; if adapter reset is forced then
2272                  * restart reset sequence again
2273                  */
2274                 if (pinstance->ioa_shutdown_type == SHUTDOWN_NONE &&
2275                     pinstance->force_ioa_reset == 0) {
2276                         pmcraid_notify_ioastate(pinstance,
2277                                                 PMC_DEVICE_EVENT_RESET_SUCCESS);
2278                         reset_complete = 1;
2279                 } else {
2280                         if (pinstance->ioa_shutdown_type != SHUTDOWN_NONE)
2281                                 pinstance->ioa_state = IOA_STATE_IN_BRINGDOWN;
2282                         pmcraid_reinit_cmdblk(cmd);
2283                         pmcraid_unregister_hcams(cmd);
2284                 }
2285                 break;
2286         }
2287 
2288         /* reset will be completed if ioa_state is either DEAD or UNKNOWN or
2289          * OPERATIONAL. Reset all control variables used during reset, wake up
2290          * any waiting threads and let the SCSI mid-layer send commands. Note
2291          * that host_lock must be held before invoking scsi_report_bus_reset.
2292          */
2293         if (reset_complete) {
2294                 pinstance->ioa_reset_in_progress = 0;
2295                 pinstance->ioa_reset_attempts = 0;
2296                 pinstance->reset_cmd = NULL;
2297                 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2298                 pinstance->ioa_bringdown = 0;
2299                 pmcraid_return_cmd(cmd);
2300 
2301                 /* If target state is to bring up the adapter, proceed with
2302                  * hcam registration and resource exposure to mid-layer.
2303                  */
2304                 if (pinstance->ioa_state == IOA_STATE_OPERATIONAL)
2305                         pmcraid_register_hcams(pinstance);
2306 
2307                 wake_up_all(&pinstance->reset_wait_q);
2308         }
2309 
2310         return;
2311 }
2312 
2313 /**
2314  * pmcraid_initiate_reset - initiates reset sequence. This is called from
2315  * ISR/tasklet during error interrupts including IOA unit check. If reset
2316  * is already in progress, it just returns, otherwise initiates IOA reset
2317  * to bring IOA up to operational state.
2318  *
2319  * @pinstance: pointer to adapter instance structure
2320  *
2321  * Return value
2322  *       none
2323  */
2324 static void pmcraid_initiate_reset(struct pmcraid_instance *pinstance)
2325 {
2326         struct pmcraid_cmd *cmd;
2327 
2328         /* If the reset is already in progress, just return, otherwise start
2329          * reset sequence and return
2330          */
2331         if (!pinstance->ioa_reset_in_progress) {
2332                 scsi_block_requests(pinstance->host);
2333                 cmd = pmcraid_get_free_cmd(pinstance);
2334 
2335                 if (cmd == NULL) {
2336                         pmcraid_err("no cmnd blocks for initiate_reset\n");
2337                         return;
2338                 }
2339 
2340                 pinstance->ioa_shutdown_type = SHUTDOWN_NONE;
2341                 pinstance->reset_cmd = cmd;
2342                 pinstance->force_ioa_reset = 1;
2343                 pmcraid_notify_ioastate(pinstance,
2344                                         PMC_DEVICE_EVENT_RESET_START);
2345                 pmcraid_ioa_reset(cmd);
2346         }
2347 }
2348 
2349 /**
2350  * pmcraid_reset_reload - utility routine for doing IOA reset either to bringup
2351  *                        or bringdown IOA
2352  * @pinstance: pointer adapter instance structure
2353  * @shutdown_type: shutdown type to be used NONE, NORMAL or ABRREV
2354  * @target_state: expected target state after reset
2355  *
2356  * Note: This command initiates reset and waits for its completion. Hence this
2357  * should not be called from isr/timer/tasklet functions (timeout handlers,
2358  * error response handlers and interrupt handlers).
2359  *
2360  * Return Value
2361  *       1 in case ioa_state is not target_state, 0 otherwise.
2362  */
2363 static int pmcraid_reset_reload(
2364         struct pmcraid_instance *pinstance,
2365         u8 shutdown_type,
2366         u8 target_state
2367 )
2368 {
2369         struct pmcraid_cmd *reset_cmd = NULL;
2370         unsigned long lock_flags;
2371         int reset = 1;
2372 
2373         spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2374 
2375         if (pinstance->ioa_reset_in_progress) {
2376                 pmcraid_info("reset_reload: reset is already in progress\n");
2377 
2378                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2379 
2380                 wait_event(pinstance->reset_wait_q,
2381                            !pinstance->ioa_reset_in_progress);
2382 
2383                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2384 
2385                 if (pinstance->ioa_state == IOA_STATE_DEAD) {
2386                         spin_unlock_irqrestore(pinstance->host->host_lock,
2387                                                lock_flags);
2388                         pmcraid_info("reset_reload: IOA is dead\n");
2389                         return reset;
2390                 } else if (pinstance->ioa_state == target_state) {
2391                         reset = 0;
2392                 }
2393         }
2394 
2395         if (reset) {
2396                 pmcraid_info("reset_reload: proceeding with reset\n");
2397                 scsi_block_requests(pinstance->host);
2398                 reset_cmd = pmcraid_get_free_cmd(pinstance);
2399 
2400                 if (reset_cmd == NULL) {
2401                         pmcraid_err("no free cmnd for reset_reload\n");
2402                         spin_unlock_irqrestore(pinstance->host->host_lock,
2403                                                lock_flags);
2404                         return reset;
2405                 }
2406 
2407                 if (shutdown_type == SHUTDOWN_NORMAL)
2408                         pinstance->ioa_bringdown = 1;
2409 
2410                 pinstance->ioa_shutdown_type = shutdown_type;
2411                 pinstance->reset_cmd = reset_cmd;
2412                 pinstance->force_ioa_reset = reset;
2413                 pmcraid_info("reset_reload: initiating reset\n");
2414                 pmcraid_ioa_reset(reset_cmd);
2415                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2416                 pmcraid_info("reset_reload: waiting for reset to complete\n");
2417                 wait_event(pinstance->reset_wait_q,
2418                            !pinstance->ioa_reset_in_progress);
2419 
2420                 pmcraid_info("reset_reload: reset is complete !!\n");
2421                 scsi_unblock_requests(pinstance->host);
2422                 if (pinstance->ioa_state == target_state)
2423                         reset = 0;
2424         }
2425 
2426         return reset;
2427 }
2428 
2429 /**
2430  * pmcraid_reset_bringdown - wrapper over pmcraid_reset_reload to bringdown IOA
2431  *
2432  * @pinstance: pointer to adapter instance structure
2433  *
2434  * Return Value
2435  *       whatever is returned from pmcraid_reset_reload
2436  */
2437 static int pmcraid_reset_bringdown(struct pmcraid_instance *pinstance)
2438 {
2439         return pmcraid_reset_reload(pinstance,
2440                                     SHUTDOWN_NORMAL,
2441                                     IOA_STATE_UNKNOWN);
2442 }
2443 
2444 /**
2445  * pmcraid_reset_bringup - wrapper over pmcraid_reset_reload to bring up IOA
2446  *
2447  * @pinstance: pointer to adapter instance structure
2448  *
2449  * Return Value
2450  *       whatever is returned from pmcraid_reset_reload
2451  */
2452 static int pmcraid_reset_bringup(struct pmcraid_instance *pinstance)
2453 {
2454         pmcraid_notify_ioastate(pinstance, PMC_DEVICE_EVENT_RESET_START);
2455 
2456         return pmcraid_reset_reload(pinstance,
2457                                     SHUTDOWN_NONE,
2458                                     IOA_STATE_OPERATIONAL);
2459 }
2460 
2461 /**
2462  * pmcraid_request_sense - Send request sense to a device
2463  * @cmd: pmcraid command struct
2464  *
2465  * This function sends a request sense to a device as a result of a check
2466  * condition. This method re-uses the same command block that failed earlier.
2467  */
2468 static void pmcraid_request_sense(struct pmcraid_cmd *cmd)
2469 {
2470         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2471         struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
2472 
2473         /* allocate DMAable memory for sense buffers */
2474         cmd->sense_buffer = pci_alloc_consistent(cmd->drv_inst->pdev,
2475                                                  SCSI_SENSE_BUFFERSIZE,
2476                                                  &cmd->sense_buffer_dma);
2477 
2478         if (cmd->sense_buffer == NULL) {
2479                 pmcraid_err
2480                         ("couldn't allocate sense buffer for request sense\n");
2481                 pmcraid_erp_done(cmd);
2482                 return;
2483         }
2484 
2485         /* re-use the command block */
2486         memset(&cmd->ioa_cb->ioasa, 0, sizeof(struct pmcraid_ioasa));
2487         memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
2488         ioarcb->request_flags0 = (SYNC_COMPLETE |
2489                                   NO_LINK_DESCS |
2490                                   INHIBIT_UL_CHECK);
2491         ioarcb->request_type = REQ_TYPE_SCSI;
2492         ioarcb->cdb[0] = REQUEST_SENSE;
2493         ioarcb->cdb[4] = SCSI_SENSE_BUFFERSIZE;
2494 
2495         ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
2496                                         offsetof(struct pmcraid_ioarcb,
2497                                                 add_data.u.ioadl[0]));
2498         ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
2499 
2500         ioarcb->data_transfer_length = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
2501 
2502         ioadl->address = cpu_to_le64(cmd->sense_buffer_dma);
2503         ioadl->data_len = cpu_to_le32(SCSI_SENSE_BUFFERSIZE);
2504         ioadl->flags = IOADL_FLAGS_LAST_DESC;
2505 
2506         /* request sense might be called as part of error response processing
2507          * which runs in tasklets context. It is possible that mid-layer might
2508          * schedule queuecommand during this time, hence, writting to IOARRIN
2509          * must be protect by host_lock
2510          */
2511         pmcraid_send_cmd(cmd, pmcraid_erp_done,
2512                          PMCRAID_REQUEST_SENSE_TIMEOUT,
2513                          pmcraid_timeout_handler);
2514 }
2515 
2516 /**
2517  * pmcraid_cancel_all - cancel all outstanding IOARCBs as part of error recovery
2518  * @cmd: command that failed
2519  * @sense: true if request_sense is required after cancel all
2520  *
2521  * This function sends a cancel all to a device to clear the queue.
2522  */
2523 static void pmcraid_cancel_all(struct pmcraid_cmd *cmd, u32 sense)
2524 {
2525         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2526         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
2527         struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
2528         void (*cmd_done) (struct pmcraid_cmd *) = sense ? pmcraid_erp_done
2529                                                         : pmcraid_request_sense;
2530 
2531         memset(ioarcb->cdb, 0, PMCRAID_MAX_CDB_LEN);
2532         ioarcb->request_flags0 = SYNC_OVERRIDE;
2533         ioarcb->request_type = REQ_TYPE_IOACMD;
2534         ioarcb->cdb[0] = PMCRAID_CANCEL_ALL_REQUESTS;
2535 
2536         if (RES_IS_GSCSI(res->cfg_entry))
2537                 ioarcb->cdb[1] = PMCRAID_SYNC_COMPLETE_AFTER_CANCEL;
2538 
2539         ioarcb->ioadl_bus_addr = 0;
2540         ioarcb->ioadl_length = 0;
2541         ioarcb->data_transfer_length = 0;
2542         ioarcb->ioarcb_bus_addr &= (~0x1FULL);
2543 
2544         /* writing to IOARRIN must be protected by host_lock, as mid-layer
2545          * schedule queuecommand while we are doing this
2546          */
2547         pmcraid_send_cmd(cmd, cmd_done,
2548                          PMCRAID_REQUEST_SENSE_TIMEOUT,
2549                          pmcraid_timeout_handler);
2550 }
2551 
2552 /**
2553  * pmcraid_frame_auto_sense: frame fixed format sense information
2554  *
2555  * @cmd: pointer to failing command block
2556  *
2557  * Return value
2558  *  none
2559  */
2560 static void pmcraid_frame_auto_sense(struct pmcraid_cmd *cmd)
2561 {
2562         u8 *sense_buf = cmd->scsi_cmd->sense_buffer;
2563         struct pmcraid_resource_entry *res = cmd->scsi_cmd->device->hostdata;
2564         struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2565         u32 ioasc = le32_to_cpu(ioasa->ioasc);
2566         u32 failing_lba = 0;
2567 
2568         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
2569         cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
2570 
2571         if (RES_IS_VSET(res->cfg_entry) &&
2572             ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC &&
2573             ioasa->u.vset.failing_lba_hi != 0) {
2574 
2575                 sense_buf[0] = 0x72;
2576                 sense_buf[1] = PMCRAID_IOASC_SENSE_KEY(ioasc);
2577                 sense_buf[2] = PMCRAID_IOASC_SENSE_CODE(ioasc);
2578                 sense_buf[3] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
2579 
2580                 sense_buf[7] = 12;
2581                 sense_buf[8] = 0;
2582                 sense_buf[9] = 0x0A;
2583                 sense_buf[10] = 0x80;
2584 
2585                 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_hi);
2586 
2587                 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
2588                 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
2589                 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
2590                 sense_buf[15] = failing_lba & 0x000000ff;
2591 
2592                 failing_lba = le32_to_cpu(ioasa->u.vset.failing_lba_lo);
2593 
2594                 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
2595                 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
2596                 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
2597                 sense_buf[19] = failing_lba & 0x000000ff;
2598         } else {
2599                 sense_buf[0] = 0x70;
2600                 sense_buf[2] = PMCRAID_IOASC_SENSE_KEY(ioasc);
2601                 sense_buf[12] = PMCRAID_IOASC_SENSE_CODE(ioasc);
2602                 sense_buf[13] = PMCRAID_IOASC_SENSE_QUAL(ioasc);
2603 
2604                 if (ioasc == PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC) {
2605                         if (RES_IS_VSET(res->cfg_entry))
2606                                 failing_lba =
2607                                         le32_to_cpu(ioasa->u.
2608                                                  vset.failing_lba_lo);
2609                         sense_buf[0] |= 0x80;
2610                         sense_buf[3] = (failing_lba >> 24) & 0xff;
2611                         sense_buf[4] = (failing_lba >> 16) & 0xff;
2612                         sense_buf[5] = (failing_lba >> 8) & 0xff;
2613                         sense_buf[6] = failing_lba & 0xff;
2614                 }
2615 
2616                 sense_buf[7] = 6; /* additional length */
2617         }
2618 }
2619 
2620 /**
2621  * pmcraid_error_handler - Error response handlers for a SCSI op
2622  * @cmd: pointer to pmcraid_cmd that has failed
2623  *
2624  * This function determines whether or not to initiate ERP on the affected
2625  * device. This is called from a tasklet, which doesn't hold any locks.
2626  *
2627  * Return value:
2628  *       0 it caller can complete the request, otherwise 1 where in error
2629  *       handler itself completes the request and returns the command block
2630  *       back to free-pool
2631  */
2632 static int pmcraid_error_handler(struct pmcraid_cmd *cmd)
2633 {
2634         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2635         struct pmcraid_resource_entry *res = scsi_cmd->device->hostdata;
2636         struct pmcraid_instance *pinstance = cmd->drv_inst;
2637         struct pmcraid_ioasa *ioasa = &cmd->ioa_cb->ioasa;
2638         u32 ioasc = le32_to_cpu(ioasa->ioasc);
2639         u32 masked_ioasc = ioasc & PMCRAID_IOASC_SENSE_MASK;
2640         u32 sense_copied = 0;
2641 
2642         if (!res) {
2643                 pmcraid_info("resource pointer is NULL\n");
2644                 return 0;
2645         }
2646 
2647         /* If this was a SCSI read/write command keep count of errors */
2648         if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_READ_CMD)
2649                 atomic_inc(&res->read_failures);
2650         else if (SCSI_CMD_TYPE(scsi_cmd->cmnd[0]) == SCSI_WRITE_CMD)
2651                 atomic_inc(&res->write_failures);
2652 
2653         if (!RES_IS_GSCSI(res->cfg_entry) &&
2654                 masked_ioasc != PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR) {
2655                 pmcraid_frame_auto_sense(cmd);
2656         }
2657 
2658         /* Log IOASC/IOASA information based on user settings */
2659         pmcraid_ioasc_logger(ioasc, cmd);
2660 
2661         switch (masked_ioasc) {
2662 
2663         case PMCRAID_IOASC_AC_TERMINATED_BY_HOST:
2664                 scsi_cmd->result |= (DID_ABORT << 16);
2665                 break;
2666 
2667         case PMCRAID_IOASC_IR_INVALID_RESOURCE_HANDLE:
2668         case PMCRAID_IOASC_HW_CANNOT_COMMUNICATE:
2669                 scsi_cmd->result |= (DID_NO_CONNECT << 16);
2670                 break;
2671 
2672         case PMCRAID_IOASC_NR_SYNC_REQUIRED:
2673                 res->sync_reqd = 1;
2674                 scsi_cmd->result |= (DID_IMM_RETRY << 16);
2675                 break;
2676 
2677         case PMCRAID_IOASC_ME_READ_ERROR_NO_REALLOC:
2678                 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
2679                 break;
2680 
2681         case PMCRAID_IOASC_UA_BUS_WAS_RESET:
2682         case PMCRAID_IOASC_UA_BUS_WAS_RESET_BY_OTHER:
2683                 if (!res->reset_progress)
2684                         scsi_report_bus_reset(pinstance->host,
2685                                               scsi_cmd->device->channel);
2686                 scsi_cmd->result |= (DID_ERROR << 16);
2687                 break;
2688 
2689         case PMCRAID_IOASC_HW_DEVICE_BUS_STATUS_ERROR:
2690                 scsi_cmd->result |= PMCRAID_IOASC_SENSE_STATUS(ioasc);
2691                 res->sync_reqd = 1;
2692 
2693                 /* if check_condition is not active return with error otherwise
2694                  * get/frame the sense buffer
2695                  */
2696                 if (PMCRAID_IOASC_SENSE_STATUS(ioasc) !=
2697                     SAM_STAT_CHECK_CONDITION &&
2698                     PMCRAID_IOASC_SENSE_STATUS(ioasc) != SAM_STAT_ACA_ACTIVE)
2699                         return 0;
2700 
2701                 /* If we have auto sense data as part of IOASA pass it to
2702                  * mid-layer
2703                  */
2704                 if (ioasa->auto_sense_length != 0) {
2705                         short sense_len = ioasa->auto_sense_length;
2706                         int data_size = min_t(u16, le16_to_cpu(sense_len),
2707                                               SCSI_SENSE_BUFFERSIZE);
2708 
2709                         memcpy(scsi_cmd->sense_buffer,
2710                                ioasa->sense_data,
2711                                data_size);
2712                         sense_copied = 1;
2713                 }
2714 
2715                 if (RES_IS_GSCSI(res->cfg_entry))
2716                         pmcraid_cancel_all(cmd, sense_copied);
2717                 else if (sense_copied)
2718                         pmcraid_erp_done(cmd);
2719                 else
2720                         pmcraid_request_sense(cmd);
2721 
2722                 return 1;
2723 
2724         case PMCRAID_IOASC_NR_INIT_CMD_REQUIRED:
2725                 break;
2726 
2727         default:
2728                 if (PMCRAID_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
2729                         scsi_cmd->result |= (DID_ERROR << 16);
2730                 break;
2731         }
2732         return 0;
2733 }
2734 
2735 /**
2736  * pmcraid_reset_device - device reset handler functions
2737  *
2738  * @scsi_cmd: scsi command struct
2739  * @modifier: reset modifier indicating the reset sequence to be performed
2740  *
2741  * This function issues a device reset to the affected device.
2742  * A LUN reset will be sent to the device first. If that does
2743  * not work, a target reset will be sent.
2744  *
2745  * Return value:
2746  *      SUCCESS / FAILED
2747  */
2748 static int pmcraid_reset_device(
2749         struct scsi_cmnd *scsi_cmd,
2750         unsigned long timeout,
2751         u8 modifier
2752 )
2753 {
2754         struct pmcraid_cmd *cmd;
2755         struct pmcraid_instance *pinstance;
2756         struct pmcraid_resource_entry *res;
2757         struct pmcraid_ioarcb *ioarcb;
2758         unsigned long lock_flags;
2759         u32 ioasc;
2760 
2761         pinstance =
2762                 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
2763         res = scsi_cmd->device->hostdata;
2764 
2765         if (!res) {
2766                 sdev_printk(KERN_ERR, scsi_cmd->device,
2767                             "reset_device: NULL resource pointer\n");
2768                 return FAILED;
2769         }
2770 
2771         /* If adapter is currently going through reset/reload, return failed.
2772          * This will force the mid-layer to call _eh_bus/host reset, which
2773          * will then go to sleep and wait for the reset to complete
2774          */
2775         spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
2776         if (pinstance->ioa_reset_in_progress ||
2777             pinstance->ioa_state == IOA_STATE_DEAD) {
2778                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2779                 return FAILED;
2780         }
2781 
2782         res->reset_progress = 1;
2783         pmcraid_info("Resetting %s resource with addr %x\n",
2784                      ((modifier & RESET_DEVICE_LUN) ? "LUN" :
2785                      ((modifier & RESET_DEVICE_TARGET) ? "TARGET" : "BUS")),
2786                      le32_to_cpu(res->cfg_entry.resource_address));
2787 
2788         /* get a free cmd block */
2789         cmd = pmcraid_get_free_cmd(pinstance);
2790 
2791         if (cmd == NULL) {
2792                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2793                 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2794                 return FAILED;
2795         }
2796 
2797         ioarcb = &cmd->ioa_cb->ioarcb;
2798         ioarcb->resource_handle = res->cfg_entry.resource_handle;
2799         ioarcb->request_type = REQ_TYPE_IOACMD;
2800         ioarcb->cdb[0] = PMCRAID_RESET_DEVICE;
2801 
2802         /* Initialize reset modifier bits */
2803         if (modifier)
2804                 modifier = ENABLE_RESET_MODIFIER | modifier;
2805 
2806         ioarcb->cdb[1] = modifier;
2807 
2808         init_completion(&cmd->wait_for_completion);
2809         cmd->completion_req = 1;
2810 
2811         pmcraid_info("cmd(CDB[0] = %x) for %x with index = %d\n",
2812                      cmd->ioa_cb->ioarcb.cdb[0],
2813                      le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle),
2814                      le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2);
2815 
2816         pmcraid_send_cmd(cmd,
2817                          pmcraid_internal_done,
2818                          timeout,
2819                          pmcraid_timeout_handler);
2820 
2821         spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
2822 
2823         /* RESET_DEVICE command completes after all pending IOARCBs are
2824          * completed. Once this command is completed, pmcraind_internal_done
2825          * will wake up the 'completion' queue.
2826          */
2827         wait_for_completion(&cmd->wait_for_completion);
2828 
2829         /* complete the command here itself and return the command block
2830          * to free list
2831          */
2832         pmcraid_return_cmd(cmd);
2833         res->reset_progress = 0;
2834         ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2835 
2836         /* set the return value based on the returned ioasc */
2837         return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
2838 }
2839 
2840 /**
2841  * _pmcraid_io_done - helper for pmcraid_io_done function
2842  *
2843  * @cmd: pointer to pmcraid command struct
2844  * @reslen: residual data length to be set in the ioasa
2845  * @ioasc: ioasc either returned by IOA or set by driver itself.
2846  *
2847  * This function is invoked by pmcraid_io_done to complete mid-layer
2848  * scsi ops.
2849  *
2850  * Return value:
2851  *        0 if caller is required to return it to free_pool. Returns 1 if
2852  *        caller need not worry about freeing command block as error handler
2853  *        will take care of that.
2854  */
2855 
2856 static int _pmcraid_io_done(struct pmcraid_cmd *cmd, int reslen, int ioasc)
2857 {
2858         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
2859         int rc = 0;
2860 
2861         scsi_set_resid(scsi_cmd, reslen);
2862 
2863         pmcraid_info("response(%d) CDB[0] = %x ioasc:result: %x:%x\n",
2864                 le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
2865                 cmd->ioa_cb->ioarcb.cdb[0],
2866                 ioasc, scsi_cmd->result);
2867 
2868         if (PMCRAID_IOASC_SENSE_KEY(ioasc) != 0)
2869                 rc = pmcraid_error_handler(cmd);
2870 
2871         if (rc == 0) {
2872                 scsi_dma_unmap(scsi_cmd);
2873                 scsi_cmd->scsi_done(scsi_cmd);
2874         }
2875 
2876         return rc;
2877 }
2878 
2879 /**
2880  * pmcraid_io_done - SCSI completion function
2881  *
2882  * @cmd: pointer to pmcraid command struct
2883  *
2884  * This function is invoked by tasklet/mid-layer error handler to completing
2885  * the SCSI ops sent from mid-layer.
2886  *
2887  * Return value
2888  *        none
2889  */
2890 
2891 static void pmcraid_io_done(struct pmcraid_cmd *cmd)
2892 {
2893         u32 ioasc = le32_to_cpu(cmd->ioa_cb->ioasa.ioasc);
2894         u32 reslen = le32_to_cpu(cmd->ioa_cb->ioasa.residual_data_length);
2895 
2896         if (_pmcraid_io_done(cmd, reslen, ioasc) == 0)
2897                 pmcraid_return_cmd(cmd);
2898 }
2899 
2900 /**
2901  * pmcraid_abort_cmd - Aborts a single IOARCB already submitted to IOA
2902  *
2903  * @cmd: command block of the command to be aborted
2904  *
2905  * Return Value:
2906  *       returns pointer to command structure used as cancelling cmd
2907  */
2908 static struct pmcraid_cmd *pmcraid_abort_cmd(struct pmcraid_cmd *cmd)
2909 {
2910         struct pmcraid_cmd *cancel_cmd;
2911         struct pmcraid_instance *pinstance;
2912         struct pmcraid_resource_entry *res;
2913 
2914         pinstance = (struct pmcraid_instance *)cmd->drv_inst;
2915         res = cmd->scsi_cmd->device->hostdata;
2916 
2917         cancel_cmd = pmcraid_get_free_cmd(pinstance);
2918 
2919         if (cancel_cmd == NULL) {
2920                 pmcraid_err("%s: no cmd blocks are available\n", __func__);
2921                 return NULL;
2922         }
2923 
2924         pmcraid_prepare_cancel_cmd(cancel_cmd, cmd);
2925 
2926         pmcraid_info("aborting command CDB[0]= %x with index = %d\n",
2927                 cmd->ioa_cb->ioarcb.cdb[0],
2928                 cmd->ioa_cb->ioarcb.response_handle >> 2);
2929 
2930         init_completion(&cancel_cmd->wait_for_completion);
2931         cancel_cmd->completion_req = 1;
2932 
2933         pmcraid_info("command (%d) CDB[0] = %x for %x\n",
2934                 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.response_handle) >> 2,
2935                 cancel_cmd->ioa_cb->ioarcb.cdb[0],
2936                 le32_to_cpu(cancel_cmd->ioa_cb->ioarcb.resource_handle));
2937 
2938         pmcraid_send_cmd(cancel_cmd,
2939                          pmcraid_internal_done,
2940                          PMCRAID_INTERNAL_TIMEOUT,
2941                          pmcraid_timeout_handler);
2942         return cancel_cmd;
2943 }
2944 
2945 /**
2946  * pmcraid_abort_complete - Waits for ABORT TASK completion
2947  *
2948  * @cancel_cmd: command block use as cancelling command
2949  *
2950  * Return Value:
2951  *       returns SUCCESS if ABORT TASK has good completion
2952  *       otherwise FAILED
2953  */
2954 static int pmcraid_abort_complete(struct pmcraid_cmd *cancel_cmd)
2955 {
2956         struct pmcraid_resource_entry *res;
2957         u32 ioasc;
2958 
2959         wait_for_completion(&cancel_cmd->wait_for_completion);
2960         res = cancel_cmd->res;
2961         cancel_cmd->res = NULL;
2962         ioasc = le32_to_cpu(cancel_cmd->ioa_cb->ioasa.ioasc);
2963 
2964         /* If the abort task is not timed out we will get a Good completion
2965          * as sense_key, otherwise we may get one the following responses
2966          * due to subsequent bus reset or device reset. In case IOASC is
2967          * NR_SYNC_REQUIRED, set sync_reqd flag for the corresponding resource
2968          */
2969         if (ioasc == PMCRAID_IOASC_UA_BUS_WAS_RESET ||
2970             ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED) {
2971                 if (ioasc == PMCRAID_IOASC_NR_SYNC_REQUIRED)
2972                         res->sync_reqd = 1;
2973                 ioasc = 0;
2974         }
2975 
2976         /* complete the command here itself */
2977         pmcraid_return_cmd(cancel_cmd);
2978         return PMCRAID_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
2979 }
2980 
2981 /**
2982  * pmcraid_eh_abort_handler - entry point for aborting a single task on errors
2983  *
2984  * @scsi_cmd:   scsi command struct given by mid-layer. When this is called
2985  *              mid-layer ensures that no other commands are queued. This
2986  *              never gets called under interrupt, but a separate eh thread.
2987  *
2988  * Return value:
2989  *       SUCCESS / FAILED
2990  */
2991 static int pmcraid_eh_abort_handler(struct scsi_cmnd *scsi_cmd)
2992 {
2993         struct pmcraid_instance *pinstance;
2994         struct pmcraid_cmd *cmd;
2995         struct pmcraid_resource_entry *res;
2996         unsigned long host_lock_flags;
2997         unsigned long pending_lock_flags;
2998         struct pmcraid_cmd *cancel_cmd = NULL;
2999         int cmd_found = 0;
3000         int rc = FAILED;
3001 
3002         pinstance =
3003                 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
3004 
3005         scmd_printk(KERN_INFO, scsi_cmd,
3006                     "I/O command timed out, aborting it.\n");
3007 
3008         res = scsi_cmd->device->hostdata;
3009 
3010         if (res == NULL)
3011                 return rc;
3012 
3013         /* If we are currently going through reset/reload, return failed.
3014          * This will force the mid-layer to eventually call
3015          * pmcraid_eh_host_reset which will then go to sleep and wait for the
3016          * reset to complete
3017          */
3018         spin_lock_irqsave(pinstance->host->host_lock, host_lock_flags);
3019 
3020         if (pinstance->ioa_reset_in_progress ||
3021             pinstance->ioa_state == IOA_STATE_DEAD) {
3022                 spin_unlock_irqrestore(pinstance->host->host_lock,
3023                                        host_lock_flags);
3024                 return rc;
3025         }
3026 
3027         /* loop over pending cmd list to find cmd corresponding to this
3028          * scsi_cmd. Note that this command might not have been completed
3029          * already. locking: all pending commands are protected with
3030          * pending_pool_lock.
3031          */
3032         spin_lock_irqsave(&pinstance->pending_pool_lock, pending_lock_flags);
3033         list_for_each_entry(cmd, &pinstance->pending_cmd_pool, free_list) {
3034 
3035                 if (cmd->scsi_cmd == scsi_cmd) {
3036                         cmd_found = 1;
3037                         break;
3038                 }
3039         }
3040 
3041         spin_unlock_irqrestore(&pinstance->pending_pool_lock,
3042                                 pending_lock_flags);
3043 
3044         /* If the command to be aborted was given to IOA and still pending with
3045          * it, send ABORT_TASK to abort this and wait for its completion
3046          */
3047         if (cmd_found)
3048                 cancel_cmd = pmcraid_abort_cmd(cmd);
3049 
3050         spin_unlock_irqrestore(pinstance->host->host_lock,
3051                                host_lock_flags);
3052 
3053         if (cancel_cmd) {
3054                 cancel_cmd->res = cmd->scsi_cmd->device->hostdata;
3055                 rc = pmcraid_abort_complete(cancel_cmd);
3056         }
3057 
3058         return cmd_found ? rc : SUCCESS;
3059 }
3060 
3061 /**
3062  * pmcraid_eh_xxxx_reset_handler - bus/target/device reset handler callbacks
3063  *
3064  * @scmd: pointer to scsi_cmd that was sent to the resource to be reset.
3065  *
3066  * All these routines invokve pmcraid_reset_device with appropriate parameters.
3067  * Since these are called from mid-layer EH thread, no other IO will be queued
3068  * to the resource being reset. However, control path (IOCTL) may be active so
3069  * it is necessary to synchronize IOARRIN writes which pmcraid_reset_device
3070  * takes care by locking/unlocking host_lock.
3071  *
3072  * Return value
3073  *      SUCCESS or FAILED
3074  */
3075 static int pmcraid_eh_device_reset_handler(struct scsi_cmnd *scmd)
3076 {
3077         scmd_printk(KERN_INFO, scmd,
3078                     "resetting device due to an I/O command timeout.\n");
3079         return pmcraid_reset_device(scmd,
3080                                     PMCRAID_INTERNAL_TIMEOUT,
3081                                     RESET_DEVICE_LUN);
3082 }
3083 
3084 static int pmcraid_eh_bus_reset_handler(struct scsi_cmnd *scmd)
3085 {
3086         scmd_printk(KERN_INFO, scmd,
3087                     "Doing bus reset due to an I/O command timeout.\n");
3088         return pmcraid_reset_device(scmd,
3089                                     PMCRAID_RESET_BUS_TIMEOUT,
3090                                     RESET_DEVICE_BUS);
3091 }
3092 
3093 static int pmcraid_eh_target_reset_handler(struct scsi_cmnd *scmd)
3094 {
3095         scmd_printk(KERN_INFO, scmd,
3096                     "Doing target reset due to an I/O command timeout.\n");
3097         return pmcraid_reset_device(scmd,
3098                                     PMCRAID_INTERNAL_TIMEOUT,
3099                                     RESET_DEVICE_TARGET);
3100 }
3101 
3102 /**
3103  * pmcraid_eh_host_reset_handler - adapter reset handler callback
3104  *
3105  * @scmd: pointer to scsi_cmd that was sent to a resource of adapter
3106  *
3107  * Initiates adapter reset to bring it up to operational state
3108  *
3109  * Return value
3110  *      SUCCESS or FAILED
3111  */
3112 static int pmcraid_eh_host_reset_handler(struct scsi_cmnd *scmd)
3113 {
3114         unsigned long interval = 10000; /* 10 seconds interval */
3115         int waits = jiffies_to_msecs(PMCRAID_RESET_HOST_TIMEOUT) / interval;
3116         struct pmcraid_instance *pinstance =
3117                 (struct pmcraid_instance *)(scmd->device->host->hostdata);
3118 
3119 
3120         /* wait for an additional 150 seconds just in case firmware could come
3121          * up and if it could complete all the pending commands excluding the
3122          * two HCAM (CCN and LDN).
3123          */
3124         while (waits--) {
3125                 if (atomic_read(&pinstance->outstanding_cmds) <=
3126                     PMCRAID_MAX_HCAM_CMD)
3127                         return SUCCESS;
3128                 msleep(interval);
3129         }
3130 
3131         dev_err(&pinstance->pdev->dev,
3132                 "Adapter being reset due to an I/O command timeout.\n");
3133         return pmcraid_reset_bringup(pinstance) == 0 ? SUCCESS : FAILED;
3134 }
3135 
3136 /**
3137  * pmcraid_init_ioadls - initializes IOADL related fields in IOARCB
3138  * @cmd: pmcraid command struct
3139  * @sgcount: count of scatter-gather elements
3140  *
3141  * Return value
3142  *   returns pointer pmcraid_ioadl_desc, initialized to point to internal
3143  *   or external IOADLs
3144  */
3145 struct pmcraid_ioadl_desc *
3146 pmcraid_init_ioadls(struct pmcraid_cmd *cmd, int sgcount)
3147 {
3148         struct pmcraid_ioadl_desc *ioadl;
3149         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3150         int ioadl_count = 0;
3151 
3152         if (ioarcb->add_cmd_param_length)
3153                 ioadl_count = DIV_ROUND_UP(ioarcb->add_cmd_param_length, 16);
3154         ioarcb->ioadl_length =
3155                 sizeof(struct pmcraid_ioadl_desc) * sgcount;
3156 
3157         if ((sgcount + ioadl_count) > (ARRAY_SIZE(ioarcb->add_data.u.ioadl))) {
3158                 /* external ioadls start at offset 0x80 from control_block
3159                  * structure, re-using 24 out of 27 ioadls part of IOARCB.
3160                  * It is necessary to indicate to firmware that driver is
3161                  * using ioadls to be treated as external to IOARCB.
3162                  */
3163                 ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
3164                 ioarcb->ioadl_bus_addr =
3165                         cpu_to_le64((cmd->ioa_cb_bus_addr) +
3166                                 offsetof(struct pmcraid_ioarcb,
3167                                         add_data.u.ioadl[3]));
3168                 ioadl = &ioarcb->add_data.u.ioadl[3];
3169         } else {
3170                 ioarcb->ioadl_bus_addr =
3171                         cpu_to_le64((cmd->ioa_cb_bus_addr) +
3172                                 offsetof(struct pmcraid_ioarcb,
3173                                         add_data.u.ioadl[ioadl_count]));
3174 
3175                 ioadl = &ioarcb->add_data.u.ioadl[ioadl_count];
3176                 ioarcb->ioarcb_bus_addr |=
3177                                 DIV_ROUND_CLOSEST(sgcount + ioadl_count, 8);
3178         }
3179 
3180         return ioadl;
3181 }
3182 
3183 /**
3184  * pmcraid_build_ioadl - Build a scatter/gather list and map the buffer
3185  * @pinstance: pointer to adapter instance structure
3186  * @cmd: pmcraid command struct
3187  *
3188  * This function is invoked by queuecommand entry point while sending a command
3189  * to firmware. This builds ioadl descriptors and sets up ioarcb fields.
3190  *
3191  * Return value:
3192  *      0 on success or -1 on failure
3193  */
3194 static int pmcraid_build_ioadl(
3195         struct pmcraid_instance *pinstance,
3196         struct pmcraid_cmd *cmd
3197 )
3198 {
3199         int i, nseg;
3200         struct scatterlist *sglist;
3201 
3202         struct scsi_cmnd *scsi_cmd = cmd->scsi_cmd;
3203         struct pmcraid_ioarcb *ioarcb = &(cmd->ioa_cb->ioarcb);
3204         struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
3205 
3206         u32 length = scsi_bufflen(scsi_cmd);
3207 
3208         if (!length)
3209                 return 0;
3210 
3211         nseg = scsi_dma_map(scsi_cmd);
3212 
3213         if (nseg < 0) {
3214                 scmd_printk(KERN_ERR, scsi_cmd, "scsi_map_dma failed!\n");
3215                 return -1;
3216         } else if (nseg > PMCRAID_MAX_IOADLS) {
3217                 scsi_dma_unmap(scsi_cmd);
3218                 scmd_printk(KERN_ERR, scsi_cmd,
3219                         "sg count is (%d) more than allowed!\n", nseg);
3220                 return -1;
3221         }
3222 
3223         /* Initialize IOARCB data transfer length fields */
3224         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE)
3225                 ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
3226 
3227         ioarcb->request_flags0 |= NO_LINK_DESCS;
3228         ioarcb->data_transfer_length = cpu_to_le32(length);
3229         ioadl = pmcraid_init_ioadls(cmd, nseg);
3230 
3231         /* Initialize IOADL descriptor addresses */
3232         scsi_for_each_sg(scsi_cmd, sglist, nseg, i) {
3233                 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sglist));
3234                 ioadl[i].address = cpu_to_le64(sg_dma_address(sglist));
3235                 ioadl[i].flags = 0;
3236         }
3237         /* setup last descriptor */
3238         ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
3239 
3240         return 0;
3241 }
3242 
3243 /**
3244  * pmcraid_free_sglist - Frees an allocated SG buffer list
3245  * @sglist: scatter/gather list pointer
3246  *
3247  * Free a DMA'able memory previously allocated with pmcraid_alloc_sglist
3248  *
3249  * Return value:
3250  *      none
3251  */
3252 static void pmcraid_free_sglist(struct pmcraid_sglist *sglist)
3253 {
3254         int i;
3255 
3256         for (i = 0; i < sglist->num_sg; i++)
3257                 __free_pages(sg_page(&(sglist->scatterlist[i])),
3258                              sglist->order);
3259 
3260         kfree(sglist);
3261 }
3262 
3263 /**
3264  * pmcraid_alloc_sglist - Allocates memory for a SG list
3265  * @buflen: buffer length
3266  *
3267  * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3268  * list.
3269  *
3270  * Return value
3271  *      pointer to sglist / NULL on failure
3272  */
3273 static struct pmcraid_sglist *pmcraid_alloc_sglist(int buflen)
3274 {
3275         struct pmcraid_sglist *sglist;
3276         struct scatterlist *scatterlist;
3277         struct page *page;
3278         int num_elem, i, j;
3279         int sg_size;
3280         int order;
3281         int bsize_elem;
3282 
3283         sg_size = buflen / (PMCRAID_MAX_IOADLS - 1);
3284         order = (sg_size > 0) ? get_order(sg_size) : 0;
3285         bsize_elem = PAGE_SIZE * (1 << order);
3286 
3287         /* Determine the actual number of sg entries needed */
3288         if (buflen % bsize_elem)
3289                 num_elem = (buflen / bsize_elem) + 1;
3290         else
3291                 num_elem = buflen / bsize_elem;
3292 
3293         /* Allocate a scatter/gather list for the DMA */
3294         sglist = kzalloc(sizeof(struct pmcraid_sglist) +
3295                          (sizeof(struct scatterlist) * (num_elem - 1)),
3296                          GFP_KERNEL);
3297 
3298         if (sglist == NULL)
3299                 return NULL;
3300 
3301         scatterlist = sglist->scatterlist;
3302         sg_init_table(scatterlist, num_elem);
3303         sglist->order = order;
3304         sglist->num_sg = num_elem;
3305         sg_size = buflen;
3306 
3307         for (i = 0; i < num_elem; i++) {
3308                 page = alloc_pages(GFP_KERNEL|GFP_DMA|__GFP_ZERO, order);
3309                 if (!page) {
3310                         for (j = i - 1; j >= 0; j--)
3311                                 __free_pages(sg_page(&scatterlist[j]), order);
3312                         kfree(sglist);
3313                         return NULL;
3314                 }
3315 
3316                 sg_set_page(&scatterlist[i], page,
3317                         sg_size < bsize_elem ? sg_size : bsize_elem, 0);
3318                 sg_size -= bsize_elem;
3319         }
3320 
3321         return sglist;
3322 }
3323 
3324 /**
3325  * pmcraid_copy_sglist - Copy user buffer to kernel buffer's SG list
3326  * @sglist: scatter/gather list pointer
3327  * @buffer: buffer pointer
3328  * @len: buffer length
3329  * @direction: data transfer direction
3330  *
3331  * Copy a user buffer into a buffer allocated by pmcraid_alloc_sglist
3332  *
3333  * Return value:
3334  * 0 on success / other on failure
3335  */
3336 static int pmcraid_copy_sglist(
3337         struct pmcraid_sglist *sglist,
3338         unsigned long buffer,
3339         u32 len,
3340         int direction
3341 )
3342 {
3343         struct scatterlist *scatterlist;
3344         void *kaddr;
3345         int bsize_elem;
3346         int i;
3347         int rc = 0;
3348 
3349         /* Determine the actual number of bytes per element */
3350         bsize_elem = PAGE_SIZE * (1 << sglist->order);
3351 
3352         scatterlist = sglist->scatterlist;
3353 
3354         for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3355                 struct page *page = sg_page(&scatterlist[i]);
3356 
3357                 kaddr = kmap(page);
3358                 if (direction == DMA_TO_DEVICE)
3359                         rc = __copy_from_user(kaddr,
3360                                               (void *)buffer,
3361                                               bsize_elem);
3362                 else
3363                         rc = __copy_to_user((void *)buffer, kaddr, bsize_elem);
3364 
3365                 kunmap(page);
3366 
3367                 if (rc) {
3368                         pmcraid_err("failed to copy user data into sg list\n");
3369                         return -EFAULT;
3370                 }
3371 
3372                 scatterlist[i].length = bsize_elem;
3373         }
3374 
3375         if (len % bsize_elem) {
3376                 struct page *page = sg_page(&scatterlist[i]);
3377 
3378                 kaddr = kmap(page);
3379 
3380                 if (direction == DMA_TO_DEVICE)
3381                         rc = __copy_from_user(kaddr,
3382                                               (void *)buffer,
3383                                               len % bsize_elem);
3384                 else
3385                         rc = __copy_to_user((void *)buffer,
3386                                             kaddr,
3387                                             len % bsize_elem);
3388 
3389                 kunmap(page);
3390 
3391                 scatterlist[i].length = len % bsize_elem;
3392         }
3393 
3394         if (rc) {
3395                 pmcraid_err("failed to copy user data into sg list\n");
3396                 rc = -EFAULT;
3397         }
3398 
3399         return rc;
3400 }
3401 
3402 /**
3403  * pmcraid_queuecommand - Queue a mid-layer request
3404  * @scsi_cmd: scsi command struct
3405  * @done: done function
3406  *
3407  * This function queues a request generated by the mid-layer. Midlayer calls
3408  * this routine within host->lock. Some of the functions called by queuecommand
3409  * would use cmd block queue locks (free_pool_lock and pending_pool_lock)
3410  *
3411  * Return value:
3412  *        0 on success
3413  *        SCSI_MLQUEUE_DEVICE_BUSY if device is busy
3414  *        SCSI_MLQUEUE_HOST_BUSY if host is busy
3415  */
3416 static int pmcraid_queuecommand_lck(
3417         struct scsi_cmnd *scsi_cmd,
3418         void (*done) (struct scsi_cmnd *)
3419 )
3420 {
3421         struct pmcraid_instance *pinstance;
3422         struct pmcraid_resource_entry *res;
3423         struct pmcraid_ioarcb *ioarcb;
3424         struct pmcraid_cmd *cmd;
3425         u32 fw_version;
3426         int rc = 0;
3427 
3428         pinstance =
3429                 (struct pmcraid_instance *)scsi_cmd->device->host->hostdata;
3430         fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
3431         scsi_cmd->scsi_done = done;
3432         res = scsi_cmd->device->hostdata;
3433         scsi_cmd->result = (DID_OK << 16);
3434 
3435         /* if adapter is marked as dead, set result to DID_NO_CONNECT complete
3436          * the command
3437          */
3438         if (pinstance->ioa_state == IOA_STATE_DEAD) {
3439                 pmcraid_info("IOA is dead, but queuecommand is scheduled\n");
3440                 scsi_cmd->result = (DID_NO_CONNECT << 16);
3441                 scsi_cmd->scsi_done(scsi_cmd);
3442                 return 0;
3443         }
3444 
3445         /* If IOA reset is in progress, can't queue the commands */
3446         if (pinstance->ioa_reset_in_progress)
3447                 return SCSI_MLQUEUE_HOST_BUSY;
3448 
3449         /* Firmware doesn't support SYNCHRONIZE_CACHE command (0x35), complete
3450          * the command here itself with success return
3451          */
3452         if (scsi_cmd->cmnd[0] == SYNCHRONIZE_CACHE) {
3453                 pmcraid_info("SYNC_CACHE(0x35), completing in driver itself\n");
3454                 scsi_cmd->scsi_done(scsi_cmd);
3455                 return 0;
3456         }
3457 
3458         /* initialize the command and IOARCB to be sent to IOA */
3459         cmd = pmcraid_get_free_cmd(pinstance);
3460 
3461         if (cmd == NULL) {
3462                 pmcraid_err("free command block is not available\n");
3463                 return SCSI_MLQUEUE_HOST_BUSY;
3464         }
3465 
3466         cmd->scsi_cmd = scsi_cmd;
3467         ioarcb = &(cmd->ioa_cb->ioarcb);
3468         memcpy(ioarcb->cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
3469         ioarcb->resource_handle = res->cfg_entry.resource_handle;
3470         ioarcb->request_type = REQ_TYPE_SCSI;
3471 
3472         /* set hrrq number where the IOA should respond to. Note that all cmds
3473          * generated internally uses hrrq_id 0, exception to this is the cmd
3474          * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses
3475          * hrrq_id assigned here in queuecommand
3476          */
3477         ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3478                           pinstance->num_hrrq;
3479         cmd->cmd_done = pmcraid_io_done;
3480 
3481         if (RES_IS_GSCSI(res->cfg_entry) || RES_IS_VSET(res->cfg_entry)) {
3482                 if (scsi_cmd->underflow == 0)
3483                         ioarcb->request_flags0 |= INHIBIT_UL_CHECK;
3484 
3485                 if (res->sync_reqd) {
3486                         ioarcb->request_flags0 |= SYNC_COMPLETE;
3487                         res->sync_reqd = 0;
3488                 }
3489 
3490                 ioarcb->request_flags0 |= NO_LINK_DESCS;
3491 
3492                 if (scsi_cmd->flags & SCMD_TAGGED)
3493                         ioarcb->request_flags1 |= TASK_TAG_SIMPLE;
3494 
3495                 if (RES_IS_GSCSI(res->cfg_entry))
3496                         ioarcb->request_flags1 |= DELAY_AFTER_RESET;
3497         }
3498 
3499         rc = pmcraid_build_ioadl(pinstance, cmd);
3500 
3501         pmcraid_info("command (%d) CDB[0] = %x for %x:%x:%x:%x\n",
3502                      le32_to_cpu(ioarcb->response_handle) >> 2,
3503                      scsi_cmd->cmnd[0], pinstance->host->unique_id,
3504                      RES_IS_VSET(res->cfg_entry) ? PMCRAID_VSET_BUS_ID :
3505                         PMCRAID_PHYS_BUS_ID,
3506                      RES_IS_VSET(res->cfg_entry) ?
3507                         (fw_version <= PMCRAID_FW_VERSION_1 ?
3508                                 res->cfg_entry.unique_flags1 :
3509                                         res->cfg_entry.array_id & 0xFF) :
3510                         RES_TARGET(res->cfg_entry.resource_address),
3511                      RES_LUN(res->cfg_entry.resource_address));
3512 
3513         if (likely(rc == 0)) {
3514                 _pmcraid_fire_command(cmd);
3515         } else {
3516                 pmcraid_err("queuecommand could not build ioadl\n");
3517                 pmcraid_return_cmd(cmd);
3518                 rc = SCSI_MLQUEUE_HOST_BUSY;
3519         }
3520 
3521         return rc;
3522 }
3523 
3524 static DEF_SCSI_QCMD(pmcraid_queuecommand)
3525 
3526 /**
3527  * pmcraid_open -char node "open" entry, allowed only users with admin access
3528  */
3529 static int pmcraid_chr_open(struct inode *inode, struct file *filep)
3530 {
3531         struct pmcraid_instance *pinstance;
3532 
3533         if (!capable(CAP_SYS_ADMIN))
3534                 return -EACCES;
3535 
3536         /* Populate adapter instance * pointer for use by ioctl */
3537         pinstance = container_of(inode->i_cdev, struct pmcraid_instance, cdev);
3538         filep->private_data = pinstance;
3539 
3540         return 0;
3541 }
3542 
3543 /**
3544  * pmcraid_fasync - Async notifier registration from applications
3545  *
3546  * This function adds the calling process to a driver global queue. When an
3547  * event occurs, SIGIO will be sent to all processes in this queue.
3548  */
3549 static int pmcraid_chr_fasync(int fd, struct file *filep, int mode)
3550 {
3551         struct pmcraid_instance *pinstance;
3552         int rc;
3553 
3554         pinstance = filep->private_data;
3555         mutex_lock(&pinstance->aen_queue_lock);
3556         rc = fasync_helper(fd, filep, mode, &pinstance->aen_queue);
3557         mutex_unlock(&pinstance->aen_queue_lock);
3558 
3559         return rc;
3560 }
3561 
3562 
3563 /**
3564  * pmcraid_build_passthrough_ioadls - builds SG elements for passthrough
3565  * commands sent over IOCTL interface
3566  *
3567  * @cmd       : pointer to struct pmcraid_cmd
3568  * @buflen    : length of the request buffer
3569  * @direction : data transfer direction
3570  *
3571  * Return value
3572  *  0 on success, non-zero error code on failure
3573  */
3574 static int pmcraid_build_passthrough_ioadls(
3575         struct pmcraid_cmd *cmd,
3576         int buflen,
3577         int direction
3578 )
3579 {
3580         struct pmcraid_sglist *sglist = NULL;
3581         struct scatterlist *sg = NULL;
3582         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
3583         struct pmcraid_ioadl_desc *ioadl;
3584         int i;
3585 
3586         sglist = pmcraid_alloc_sglist(buflen);
3587 
3588         if (!sglist) {
3589                 pmcraid_err("can't allocate memory for passthrough SGls\n");
3590                 return -ENOMEM;
3591         }
3592 
3593         sglist->num_dma_sg = pci_map_sg(cmd->drv_inst->pdev,
3594                                         sglist->scatterlist,
3595                                         sglist->num_sg, direction);
3596 
3597         if (!sglist->num_dma_sg || sglist->num_dma_sg > PMCRAID_MAX_IOADLS) {
3598                 dev_err(&cmd->drv_inst->pdev->dev,
3599                         "Failed to map passthrough buffer!\n");
3600                 pmcraid_free_sglist(sglist);
3601                 return -EIO;
3602         }
3603 
3604         cmd->sglist = sglist;
3605         ioarcb->request_flags0 |= NO_LINK_DESCS;
3606 
3607         ioadl = pmcraid_init_ioadls(cmd, sglist->num_dma_sg);
3608 
3609         /* Initialize IOADL descriptor addresses */
3610         for_each_sg(sglist->scatterlist, sg, sglist->num_dma_sg, i) {
3611                 ioadl[i].data_len = cpu_to_le32(sg_dma_len(sg));
3612                 ioadl[i].address = cpu_to_le64(sg_dma_address(sg));
3613                 ioadl[i].flags = 0;
3614         }
3615 
3616         /* setup the last descriptor */
3617         ioadl[i - 1].flags = IOADL_FLAGS_LAST_DESC;
3618 
3619         return 0;
3620 }
3621 
3622 
3623 /**
3624  * pmcraid_release_passthrough_ioadls - release passthrough ioadls
3625  *
3626  * @cmd: pointer to struct pmcraid_cmd for which ioadls were allocated
3627  * @buflen: size of the request buffer
3628  * @direction: data transfer direction
3629  *
3630  * Return value
3631  *  0 on success, non-zero error code on failure
3632  */
3633 static void pmcraid_release_passthrough_ioadls(
3634         struct pmcraid_cmd *cmd,
3635         int buflen,
3636         int direction
3637 )
3638 {
3639         struct pmcraid_sglist *sglist = cmd->sglist;
3640 
3641         if (buflen > 0) {
3642                 pci_unmap_sg(cmd->drv_inst->pdev,
3643                              sglist->scatterlist,
3644                              sglist->num_sg,
3645                              direction);
3646                 pmcraid_free_sglist(sglist);
3647                 cmd->sglist = NULL;
3648         }
3649 }
3650 
3651 /**
3652  * pmcraid_ioctl_passthrough - handling passthrough IOCTL commands
3653  *
3654  * @pinstance: pointer to adapter instance structure
3655  * @cmd: ioctl code
3656  * @arg: pointer to pmcraid_passthrough_buffer user buffer
3657  *
3658  * Return value
3659  *  0 on success, non-zero error code on failure
3660  */
3661 static long pmcraid_ioctl_passthrough(
3662         struct pmcraid_instance *pinstance,
3663         unsigned int ioctl_cmd,
3664         unsigned int buflen,
3665         unsigned long arg
3666 )
3667 {
3668         struct pmcraid_passthrough_ioctl_buffer *buffer;
3669         struct pmcraid_ioarcb *ioarcb;
3670         struct pmcraid_cmd *cmd;
3671         struct pmcraid_cmd *cancel_cmd;
3672         unsigned long request_buffer;
3673         unsigned long request_offset;
3674         unsigned long lock_flags;
3675         void *ioasa;
3676         u32 ioasc;
3677         int request_size;
3678         int buffer_size;
3679         u8 access, direction;
3680         int rc = 0;
3681 
3682         /* If IOA reset is in progress, wait 10 secs for reset to complete */
3683         if (pinstance->ioa_reset_in_progress) {
3684                 rc = wait_event_interruptible_timeout(
3685                                 pinstance->reset_wait_q,
3686                                 !pinstance->ioa_reset_in_progress,
3687                                 msecs_to_jiffies(10000));
3688 
3689                 if (!rc)
3690                         return -ETIMEDOUT;
3691                 else if (rc < 0)
3692                         return -ERESTARTSYS;
3693         }
3694 
3695         /* If adapter is not in operational state, return error */
3696         if (pinstance->ioa_state != IOA_STATE_OPERATIONAL) {
3697                 pmcraid_err("IOA is not operational\n");
3698                 return -ENOTTY;
3699         }
3700 
3701         buffer_size = sizeof(struct pmcraid_passthrough_ioctl_buffer);
3702         buffer = kmalloc(buffer_size, GFP_KERNEL);
3703 
3704         if (!buffer) {
3705                 pmcraid_err("no memory for passthrough buffer\n");
3706                 return -ENOMEM;
3707         }
3708 
3709         request_offset =
3710             offsetof(struct pmcraid_passthrough_ioctl_buffer, request_buffer);
3711 
3712         request_buffer = arg + request_offset;
3713 
3714         rc = __copy_from_user(buffer,
3715                              (struct pmcraid_passthrough_ioctl_buffer *) arg,
3716                              sizeof(struct pmcraid_passthrough_ioctl_buffer));
3717 
3718         ioasa =
3719         (void *)(arg +
3720                 offsetof(struct pmcraid_passthrough_ioctl_buffer, ioasa));
3721 
3722         if (rc) {
3723                 pmcraid_err("ioctl: can't copy passthrough buffer\n");
3724                 rc = -EFAULT;
3725                 goto out_free_buffer;
3726         }
3727 
3728         request_size = buffer->ioarcb.data_transfer_length;
3729 
3730         if (buffer->ioarcb.request_flags0 & TRANSFER_DIR_WRITE) {
3731                 access = VERIFY_READ;
3732                 direction = DMA_TO_DEVICE;
3733         } else {
3734                 access = VERIFY_WRITE;
3735                 direction = DMA_FROM_DEVICE;
3736         }
3737 
3738         if (request_size > 0) {
3739                 rc = access_ok(access, arg, request_offset + request_size);
3740 
3741                 if (!rc) {
3742                         rc = -EFAULT;
3743                         goto out_free_buffer;
3744                 }
3745         } else if (request_size < 0) {
3746                 rc = -EINVAL;
3747                 goto out_free_buffer;
3748         }
3749 
3750         /* check if we have any additional command parameters */
3751         if (buffer->ioarcb.add_cmd_param_length > PMCRAID_ADD_CMD_PARAM_LEN) {
3752                 rc = -EINVAL;
3753                 goto out_free_buffer;
3754         }
3755 
3756         cmd = pmcraid_get_free_cmd(pinstance);
3757 
3758         if (!cmd) {
3759                 pmcraid_err("free command block is not available\n");
3760                 rc = -ENOMEM;
3761                 goto out_free_buffer;
3762         }
3763 
3764         cmd->scsi_cmd = NULL;
3765         ioarcb = &(cmd->ioa_cb->ioarcb);
3766 
3767         /* Copy the user-provided IOARCB stuff field by field */
3768         ioarcb->resource_handle = buffer->ioarcb.resource_handle;
3769         ioarcb->data_transfer_length = buffer->ioarcb.data_transfer_length;
3770         ioarcb->cmd_timeout = buffer->ioarcb.cmd_timeout;
3771         ioarcb->request_type = buffer->ioarcb.request_type;
3772         ioarcb->request_flags0 = buffer->ioarcb.request_flags0;
3773         ioarcb->request_flags1 = buffer->ioarcb.request_flags1;
3774         memcpy(ioarcb->cdb, buffer->ioarcb.cdb, PMCRAID_MAX_CDB_LEN);
3775 
3776         if (buffer->ioarcb.add_cmd_param_length) {
3777                 ioarcb->add_cmd_param_length =
3778                         buffer->ioarcb.add_cmd_param_length;
3779                 ioarcb->add_cmd_param_offset =
3780                         buffer->ioarcb.add_cmd_param_offset;
3781                 memcpy(ioarcb->add_data.u.add_cmd_params,
3782                         buffer->ioarcb.add_data.u.add_cmd_params,
3783                         buffer->ioarcb.add_cmd_param_length);
3784         }
3785 
3786         /* set hrrq number where the IOA should respond to. Note that all cmds
3787          * generated internally uses hrrq_id 0, exception to this is the cmd
3788          * block of scsi_cmd which is re-used (e.g. cancel/abort), which uses
3789          * hrrq_id assigned here in queuecommand
3790          */
3791         ioarcb->hrrq_id = atomic_add_return(1, &(pinstance->last_message_id)) %
3792                           pinstance->num_hrrq;
3793 
3794         if (request_size) {
3795                 rc = pmcraid_build_passthrough_ioadls(cmd,
3796                                                       request_size,
3797                                                       direction);
3798                 if (rc) {
3799                         pmcraid_err("couldn't build passthrough ioadls\n");
3800                         goto out_free_buffer;
3801                 }
3802         } else if (request_size < 0) {
3803                 rc = -EINVAL;
3804                 goto out_free_buffer;
3805         }
3806 
3807         /* If data is being written into the device, copy the data from user
3808          * buffers
3809          */
3810         if (direction == DMA_TO_DEVICE && request_size > 0) {
3811                 rc = pmcraid_copy_sglist(cmd->sglist,
3812                                          request_buffer,
3813                                          request_size,
3814                                          direction);
3815                 if (rc) {
3816                         pmcraid_err("failed to copy user buffer\n");
3817                         goto out_free_sglist;
3818                 }
3819         }
3820 
3821         /* passthrough ioctl is a blocking command so, put the user to sleep
3822          * until timeout. Note that a timeout value of 0 means, do timeout.
3823          */
3824         cmd->cmd_done = pmcraid_internal_done;
3825         init_completion(&cmd->wait_for_completion);
3826         cmd->completion_req = 1;
3827 
3828         pmcraid_info("command(%d) (CDB[0] = %x) for %x\n",
3829                      le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle) >> 2,
3830                      cmd->ioa_cb->ioarcb.cdb[0],
3831                      le32_to_cpu(cmd->ioa_cb->ioarcb.resource_handle));
3832 
3833         spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3834         _pmcraid_fire_command(cmd);
3835         spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3836 
3837         /* NOTE ! Remove the below line once abort_task is implemented
3838          * in firmware. This line disables ioctl command timeout handling logic
3839          * similar to IO command timeout handling, making ioctl commands to wait
3840          * until the command completion regardless of timeout value specified in
3841          * ioarcb
3842          */
3843         buffer->ioarcb.cmd_timeout = 0;
3844 
3845         /* If command timeout is specified put caller to wait till that time,
3846          * otherwise it would be blocking wait. If command gets timed out, it
3847          * will be aborted.
3848          */
3849         if (buffer->ioarcb.cmd_timeout == 0) {
3850                 wait_for_completion(&cmd->wait_for_completion);
3851         } else if (!wait_for_completion_timeout(
3852                         &cmd->wait_for_completion,
3853                         msecs_to_jiffies(buffer->ioarcb.cmd_timeout * 1000))) {
3854 
3855                 pmcraid_info("aborting cmd %d (CDB[0] = %x) due to timeout\n",
3856                         le32_to_cpu(cmd->ioa_cb->ioarcb.response_handle >> 2),
3857                         cmd->ioa_cb->ioarcb.cdb[0]);
3858 
3859                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
3860                 cancel_cmd = pmcraid_abort_cmd(cmd);
3861                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
3862 
3863                 if (cancel_cmd) {
3864                         wait_for_completion(&cancel_cmd->wait_for_completion);
3865                         ioasc = cancel_cmd->ioa_cb->ioasa.ioasc;
3866                         pmcraid_return_cmd(cancel_cmd);
3867 
3868                         /* if abort task couldn't find the command i.e it got
3869                          * completed prior to aborting, return good completion.
3870                          * if command got aborted successfully or there was IOA
3871                          * reset due to abort task itself getting timedout then
3872                          * return -ETIMEDOUT
3873                          */
3874                         if (ioasc == PMCRAID_IOASC_IOA_WAS_RESET ||
3875                             PMCRAID_IOASC_SENSE_KEY(ioasc) == 0x00) {
3876                                 if (ioasc != PMCRAID_IOASC_GC_IOARCB_NOTFOUND)
3877                                         rc = -ETIMEDOUT;
3878                                 goto out_handle_response;
3879                         }
3880                 }
3881 
3882                 /* no command block for abort task or abort task failed to abort
3883                  * the IOARCB, then wait for 150 more seconds and initiate reset
3884                  * sequence after timeout
3885                  */
3886                 if (!wait_for_completion_timeout(
3887                         &cmd->wait_for_completion,
3888                         msecs_to_jiffies(150 * 1000))) {
3889                         pmcraid_reset_bringup(cmd->drv_inst);
3890                         rc = -ETIMEDOUT;
3891                 }
3892         }
3893 
3894 out_handle_response:
3895         /* copy entire IOASA buffer and return IOCTL success.
3896          * If copying IOASA to user-buffer fails, return
3897          * EFAULT
3898          */
3899         if (copy_to_user(ioasa, &cmd->ioa_cb->ioasa,
3900                 sizeof(struct pmcraid_ioasa))) {
3901                 pmcraid_err("failed to copy ioasa buffer to user\n");
3902                 rc = -EFAULT;
3903         }
3904 
3905         /* If the data transfer was from device, copy the data onto user
3906          * buffers
3907          */
3908         else if (direction == DMA_FROM_DEVICE && request_size > 0) {
3909                 rc = pmcraid_copy_sglist(cmd->sglist,
3910                                          request_buffer,
3911                                          request_size,
3912                                          direction);
3913                 if (rc) {
3914                         pmcraid_err("failed to copy user buffer\n");
3915                         rc = -EFAULT;
3916                 }
3917         }
3918 
3919 out_free_sglist:
3920         pmcraid_release_passthrough_ioadls(cmd, request_size, direction);
3921         pmcraid_return_cmd(cmd);
3922 
3923 out_free_buffer:
3924         kfree(buffer);
3925 
3926         return rc;
3927 }
3928 
3929 
3930 
3931 
3932 /**
3933  * pmcraid_ioctl_driver - ioctl handler for commands handled by driver itself
3934  *
3935  * @pinstance: pointer to adapter instance structure
3936  * @cmd: ioctl command passed in
3937  * @buflen: length of user_buffer
3938  * @user_buffer: user buffer pointer
3939  *
3940  * Return Value
3941  *   0 in case of success, otherwise appropriate error code
3942  */
3943 static long pmcraid_ioctl_driver(
3944         struct pmcraid_instance *pinstance,
3945         unsigned int cmd,
3946         unsigned int buflen,
3947         void __user *user_buffer
3948 )
3949 {
3950         int rc = -ENOSYS;
3951 
3952         if (!access_ok(VERIFY_READ, user_buffer, _IOC_SIZE(cmd))) {
3953                 pmcraid_err("ioctl_driver: access fault in request buffer\n");
3954                 return -EFAULT;
3955         }
3956 
3957         switch (cmd) {
3958         case PMCRAID_IOCTL_RESET_ADAPTER:
3959                 pmcraid_reset_bringup(pinstance);
3960                 rc = 0;
3961                 break;
3962 
3963         default:
3964                 break;
3965         }
3966 
3967         return rc;
3968 }
3969 
3970 /**
3971  * pmcraid_check_ioctl_buffer - check for proper access to user buffer
3972  *
3973  * @cmd: ioctl command
3974  * @arg: user buffer
3975  * @hdr: pointer to kernel memory for pmcraid_ioctl_header
3976  *
3977  * Return Value
3978  *      negetive error code if there are access issues, otherwise zero.
3979  *      Upon success, returns ioctl header copied out of user buffer.
3980  */
3981 
3982 static int pmcraid_check_ioctl_buffer(
3983         int cmd,
3984         void __user *arg,
3985         struct pmcraid_ioctl_header *hdr
3986 )
3987 {
3988         int rc = 0;
3989         int access = VERIFY_READ;
3990 
3991         if (copy_from_user(hdr, arg, sizeof(struct pmcraid_ioctl_header))) {
3992                 pmcraid_err("couldn't copy ioctl header from user buffer\n");
3993                 return -EFAULT;
3994         }
3995 
3996         /* check for valid driver signature */
3997         rc = memcmp(hdr->signature,
3998                     PMCRAID_IOCTL_SIGNATURE,
3999                     sizeof(hdr->signature));
4000         if (rc) {
4001                 pmcraid_err("signature verification failed\n");
4002                 return -EINVAL;
4003         }
4004 
4005         /* check for appropriate buffer access */
4006         if ((_IOC_DIR(cmd) & _IOC_READ) == _IOC_READ)
4007                 access = VERIFY_WRITE;
4008 
4009         rc = access_ok(access,
4010                        (arg + sizeof(struct pmcraid_ioctl_header)),
4011                        hdr->buffer_length);
4012         if (!rc) {
4013                 pmcraid_err("access failed for user buffer of size %d\n",
4014                              hdr->buffer_length);
4015                 return -EFAULT;
4016         }
4017 
4018         return 0;
4019 }
4020 
4021 /**
4022  *  pmcraid_ioctl - char node ioctl entry point
4023  */
4024 static long pmcraid_chr_ioctl(
4025         struct file *filep,
4026         unsigned int cmd,
4027         unsigned long arg
4028 )
4029 {
4030         struct pmcraid_instance *pinstance = NULL;
4031         struct pmcraid_ioctl_header *hdr = NULL;
4032         int retval = -ENOTTY;
4033 
4034         hdr = kmalloc(sizeof(struct pmcraid_ioctl_header), GFP_KERNEL);
4035 
4036         if (!hdr) {
4037                 pmcraid_err("failed to allocate memory for ioctl header\n");
4038                 return -ENOMEM;
4039         }
4040 
4041         retval = pmcraid_check_ioctl_buffer(cmd, (void *)arg, hdr);
4042 
4043         if (retval) {
4044                 pmcraid_info("chr_ioctl: header check failed\n");
4045                 kfree(hdr);
4046                 return retval;
4047         }
4048 
4049         pinstance = filep->private_data;
4050 
4051         if (!pinstance) {
4052                 pmcraid_info("adapter instance is not found\n");
4053                 kfree(hdr);
4054                 return -ENOTTY;
4055         }
4056 
4057         switch (_IOC_TYPE(cmd)) {
4058 
4059         case PMCRAID_PASSTHROUGH_IOCTL:
4060                 /* If ioctl code is to download microcode, we need to block
4061                  * mid-layer requests.
4062                  */
4063                 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4064                         scsi_block_requests(pinstance->host);
4065 
4066                 retval = pmcraid_ioctl_passthrough(pinstance,
4067                                                    cmd,
4068                                                    hdr->buffer_length,
4069                                                    arg);
4070 
4071                 if (cmd == PMCRAID_IOCTL_DOWNLOAD_MICROCODE)
4072                         scsi_unblock_requests(pinstance->host);
4073                 break;
4074 
4075         case PMCRAID_DRIVER_IOCTL:
4076                 arg += sizeof(struct pmcraid_ioctl_header);
4077                 retval = pmcraid_ioctl_driver(pinstance,
4078                                               cmd,
4079                                               hdr->buffer_length,
4080                                               (void __user *)arg);
4081                 break;
4082 
4083         default:
4084                 retval = -ENOTTY;
4085                 break;
4086         }
4087 
4088         kfree(hdr);
4089 
4090         return retval;
4091 }
4092 
4093 /**
4094  * File operations structure for management interface
4095  */
4096 static const struct file_operations pmcraid_fops = {
4097         .owner = THIS_MODULE,
4098         .open = pmcraid_chr_open,
4099         .fasync = pmcraid_chr_fasync,
4100         .unlocked_ioctl = pmcraid_chr_ioctl,
4101 #ifdef CONFIG_COMPAT
4102         .compat_ioctl = pmcraid_chr_ioctl,
4103 #endif
4104         .llseek = noop_llseek,
4105 };
4106 
4107 
4108 
4109 
4110 /**
4111  * pmcraid_show_log_level - Display adapter's error logging level
4112  * @dev: class device struct
4113  * @buf: buffer
4114  *
4115  * Return value:
4116  *  number of bytes printed to buffer
4117  */
4118 static ssize_t pmcraid_show_log_level(
4119         struct device *dev,
4120         struct device_attribute *attr,
4121         char *buf)
4122 {
4123         struct Scsi_Host *shost = class_to_shost(dev);
4124         struct pmcraid_instance *pinstance =
4125                 (struct pmcraid_instance *)shost->hostdata;
4126         return snprintf(buf, PAGE_SIZE, "%d\n", pinstance->current_log_level);
4127 }
4128 
4129 /**
4130  * pmcraid_store_log_level - Change the adapter's error logging level
4131  * @dev: class device struct
4132  * @buf: buffer
4133  * @count: not used
4134  *
4135  * Return value:
4136  *  number of bytes printed to buffer
4137  */
4138 static ssize_t pmcraid_store_log_level(
4139         struct device *dev,
4140         struct device_attribute *attr,
4141         const char *buf,
4142         size_t count
4143 )
4144 {
4145         struct Scsi_Host *shost;
4146         struct pmcraid_instance *pinstance;
4147         u8 val;
4148 
4149         if (kstrtou8(buf, 10, &val))
4150                 return -EINVAL;
4151         /* log-level should be from 0 to 2 */
4152         if (val > 2)
4153                 return -EINVAL;
4154 
4155         shost = class_to_shost(dev);
4156         pinstance = (struct pmcraid_instance *)shost->hostdata;
4157         pinstance->current_log_level = val;
4158 
4159         return strlen(buf);
4160 }
4161 
4162 static struct device_attribute pmcraid_log_level_attr = {
4163         .attr = {
4164                  .name = "log_level",
4165                  .mode = S_IRUGO | S_IWUSR,
4166                  },
4167         .show = pmcraid_show_log_level,
4168         .store = pmcraid_store_log_level,
4169 };
4170 
4171 /**
4172  * pmcraid_show_drv_version - Display driver version
4173  * @dev: class device struct
4174  * @buf: buffer
4175  *
4176  * Return value:
4177  *  number of bytes printed to buffer
4178  */
4179 static ssize_t pmcraid_show_drv_version(
4180         struct device *dev,
4181         struct device_attribute *attr,
4182         char *buf
4183 )
4184 {
4185         return snprintf(buf, PAGE_SIZE, "version: %s\n",
4186                         PMCRAID_DRIVER_VERSION);
4187 }
4188 
4189 static struct device_attribute pmcraid_driver_version_attr = {
4190         .attr = {
4191                  .name = "drv_version",
4192                  .mode = S_IRUGO,
4193                  },
4194         .show = pmcraid_show_drv_version,
4195 };
4196 
4197 /**
4198  * pmcraid_show_io_adapter_id - Display driver assigned adapter id
4199  * @dev: class device struct
4200  * @buf: buffer
4201  *
4202  * Return value:
4203  *  number of bytes printed to buffer
4204  */
4205 static ssize_t pmcraid_show_adapter_id(
4206         struct device *dev,
4207         struct device_attribute *attr,
4208         char *buf
4209 )
4210 {
4211         struct Scsi_Host *shost = class_to_shost(dev);
4212         struct pmcraid_instance *pinstance =
4213                 (struct pmcraid_instance *)shost->hostdata;
4214         u32 adapter_id = (pinstance->pdev->bus->number << 8) |
4215                 pinstance->pdev->devfn;
4216         u32 aen_group = pmcraid_event_family.id;
4217 
4218         return snprintf(buf, PAGE_SIZE,
4219                         "adapter id: %d\nminor: %d\naen group: %d\n",
4220                         adapter_id, MINOR(pinstance->cdev.dev), aen_group);
4221 }
4222 
4223 static struct device_attribute pmcraid_adapter_id_attr = {
4224         .attr = {
4225                  .name = "adapter_id",
4226                  .mode = S_IRUGO | S_IWUSR,
4227                  },
4228         .show = pmcraid_show_adapter_id,
4229 };
4230 
4231 static struct device_attribute *pmcraid_host_attrs[] = {
4232         &pmcraid_log_level_attr,
4233         &pmcraid_driver_version_attr,
4234         &pmcraid_adapter_id_attr,
4235         NULL,
4236 };
4237 
4238 
4239 /* host template structure for pmcraid driver */
4240 static struct scsi_host_template pmcraid_host_template = {
4241         .module = THIS_MODULE,
4242         .name = PMCRAID_DRIVER_NAME,
4243         .queuecommand = pmcraid_queuecommand,
4244         .eh_abort_handler = pmcraid_eh_abort_handler,
4245         .eh_bus_reset_handler = pmcraid_eh_bus_reset_handler,
4246         .eh_target_reset_handler = pmcraid_eh_target_reset_handler,
4247         .eh_device_reset_handler = pmcraid_eh_device_reset_handler,
4248         .eh_host_reset_handler = pmcraid_eh_host_reset_handler,
4249 
4250         .slave_alloc = pmcraid_slave_alloc,
4251         .slave_configure = pmcraid_slave_configure,
4252         .slave_destroy = pmcraid_slave_destroy,
4253         .change_queue_depth = pmcraid_change_queue_depth,
4254         .can_queue = PMCRAID_MAX_IO_CMD,
4255         .this_id = -1,
4256         .sg_tablesize = PMCRAID_MAX_IOADLS,
4257         .max_sectors = PMCRAID_IOA_MAX_SECTORS,
4258         .no_write_same = 1,
4259         .cmd_per_lun = PMCRAID_MAX_CMD_PER_LUN,
4260         .use_clustering = ENABLE_CLUSTERING,
4261         .shost_attrs = pmcraid_host_attrs,
4262         .proc_name = PMCRAID_DRIVER_NAME,
4263         .use_blk_tags = 1,
4264 };
4265 
4266 /*
4267  * pmcraid_isr_msix - implements MSI-X interrupt handling routine
4268  * @irq: interrupt vector number
4269  * @dev_id: pointer hrrq_vector
4270  *
4271  * Return Value
4272  *       IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored
4273  */
4274 
4275 static irqreturn_t pmcraid_isr_msix(int irq, void *dev_id)
4276 {
4277         struct pmcraid_isr_param *hrrq_vector;
4278         struct pmcraid_instance *pinstance;
4279         unsigned long lock_flags;
4280         u32 intrs_val;
4281         int hrrq_id;
4282 
4283         hrrq_vector = (struct pmcraid_isr_param *)dev_id;
4284         hrrq_id = hrrq_vector->hrrq_id;
4285         pinstance = hrrq_vector->drv_inst;
4286 
4287         if (!hrrq_id) {
4288                 /* Read the interrupt */
4289                 intrs_val = pmcraid_read_interrupts(pinstance);
4290                 if (intrs_val &&
4291                         ((ioread32(pinstance->int_regs.host_ioa_interrupt_reg)
4292                         & DOORBELL_INTR_MSIX_CLR) == 0)) {
4293                         /* Any error interrupts including unit_check,
4294                          * initiate IOA reset.In case of unit check indicate
4295                          * to reset_sequence that IOA unit checked and prepare
4296                          * for a dump during reset sequence
4297                          */
4298                         if (intrs_val & PMCRAID_ERROR_INTERRUPTS) {
4299                                 if (intrs_val & INTRS_IOA_UNIT_CHECK)
4300                                         pinstance->ioa_unit_check = 1;
4301 
4302                                 pmcraid_err("ISR: error interrupts: %x \
4303                                         initiating reset\n", intrs_val);
4304                                 spin_lock_irqsave(pinstance->host->host_lock,
4305                                         lock_flags);
4306                                 pmcraid_initiate_reset(pinstance);
4307                                 spin_unlock_irqrestore(
4308                                         pinstance->host->host_lock,
4309                                         lock_flags);
4310                         }
4311                         /* If interrupt was as part of the ioa initialization,
4312                          * clear it. Delete the timer and wakeup the
4313                          * reset engine to proceed with reset sequence
4314                          */
4315                         if (intrs_val & INTRS_TRANSITION_TO_OPERATIONAL)
4316                                 pmcraid_clr_trans_op(pinstance);
4317 
4318                         /* Clear the interrupt register by writing
4319                          * to host to ioa doorbell. Once done
4320                          * FW will clear the interrupt.
4321                          */
4322                         iowrite32(DOORBELL_INTR_MSIX_CLR,
4323                                 pinstance->int_regs.host_ioa_interrupt_reg);
4324                         ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4325 
4326 
4327                 }
4328         }
4329 
4330         tasklet_schedule(&(pinstance->isr_tasklet[hrrq_id]));
4331 
4332         return IRQ_HANDLED;
4333 }
4334 
4335 /**
4336  * pmcraid_isr  - implements legacy interrupt handling routine
4337  *
4338  * @irq: interrupt vector number
4339  * @dev_id: pointer hrrq_vector
4340  *
4341  * Return Value
4342  *       IRQ_HANDLED if interrupt is handled or IRQ_NONE if ignored
4343  */
4344 static irqreturn_t pmcraid_isr(int irq, void *dev_id)
4345 {
4346         struct pmcraid_isr_param *hrrq_vector;
4347         struct pmcraid_instance *pinstance;
4348         u32 intrs;
4349         unsigned long lock_flags;
4350         int hrrq_id = 0;
4351 
4352         /* In case of legacy interrupt mode where interrupts are shared across
4353          * isrs, it may be possible that the current interrupt is not from IOA
4354          */
4355         if (!dev_id) {
4356                 printk(KERN_INFO "%s(): NULL host pointer\n", __func__);
4357                 return IRQ_NONE;
4358         }
4359         hrrq_vector = (struct pmcraid_isr_param *)dev_id;
4360         pinstance = hrrq_vector->drv_inst;
4361 
4362         intrs = pmcraid_read_interrupts(pinstance);
4363 
4364         if (unlikely((intrs & PMCRAID_PCI_INTERRUPTS) == 0))
4365                 return IRQ_NONE;
4366 
4367         /* Any error interrupts including unit_check, initiate IOA reset.
4368          * In case of unit check indicate to reset_sequence that IOA unit
4369          * checked and prepare for a dump during reset sequence
4370          */
4371         if (intrs & PMCRAID_ERROR_INTERRUPTS) {
4372 
4373                 if (intrs & INTRS_IOA_UNIT_CHECK)
4374                         pinstance->ioa_unit_check = 1;
4375 
4376                 iowrite32(intrs,
4377                           pinstance->int_regs.ioa_host_interrupt_clr_reg);
4378                 pmcraid_err("ISR: error interrupts: %x initiating reset\n",
4379                             intrs);
4380                 intrs = ioread32(
4381                                 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4382                 spin_lock_irqsave(pinstance->host->host_lock, lock_flags);
4383                 pmcraid_initiate_reset(pinstance);
4384                 spin_unlock_irqrestore(pinstance->host->host_lock, lock_flags);
4385         } else {
4386                 /* If interrupt was as part of the ioa initialization,
4387                  * clear. Delete the timer and wakeup the
4388                  * reset engine to proceed with reset sequence
4389                  */
4390                 if (intrs & INTRS_TRANSITION_TO_OPERATIONAL) {
4391                         pmcraid_clr_trans_op(pinstance);
4392                 } else {
4393                         iowrite32(intrs,
4394                                 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4395                         ioread32(
4396                                 pinstance->int_regs.ioa_host_interrupt_clr_reg);
4397 
4398                         tasklet_schedule(
4399                                         &(pinstance->isr_tasklet[hrrq_id]));
4400                 }
4401         }
4402 
4403         return IRQ_HANDLED;
4404 }
4405 
4406 
4407 /**
4408  * pmcraid_worker_function -  worker thread function
4409  *
4410  * @workp: pointer to struct work queue
4411  *
4412  * Return Value
4413  *       None
4414  */
4415 
4416 static void pmcraid_worker_function(struct work_struct *workp)
4417 {
4418         struct pmcraid_instance *pinstance;
4419         struct pmcraid_resource_entry *res;
4420         struct pmcraid_resource_entry *temp;
4421         struct scsi_device *sdev;
4422         unsigned long lock_flags;
4423         unsigned long host_lock_flags;
4424         u16 fw_version;
4425         u8 bus, target, lun;
4426 
4427         pinstance = container_of(workp, struct pmcraid_instance, worker_q);
4428         /* add resources only after host is added into system */
4429         if (!atomic_read(&pinstance->expose_resources))
4430                 return;
4431 
4432         fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
4433 
4434         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
4435         list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue) {
4436 
4437                 if (res->change_detected == RES_CHANGE_DEL && res->scsi_dev) {
4438                         sdev = res->scsi_dev;
4439 
4440                         /* host_lock must be held before calling
4441                          * scsi_device_get
4442                          */
4443                         spin_lock_irqsave(pinstance->host->host_lock,
4444                                           host_lock_flags);
4445                         if (!scsi_device_get(sdev)) {
4446                                 spin_unlock_irqrestore(
4447                                                 pinstance->host->host_lock,
4448                                                 host_lock_flags);
4449                                 pmcraid_info("deleting %x from midlayer\n",
4450                                              res->cfg_entry.resource_address);
4451                                 list_move_tail(&res->queue,
4452                                                 &pinstance->free_res_q);
4453                                 spin_unlock_irqrestore(
4454                                         &pinstance->resource_lock,
4455                                         lock_flags);
4456                                 scsi_remove_device(sdev);
4457                                 scsi_device_put(sdev);
4458                                 spin_lock_irqsave(&pinstance->resource_lock,
4459                                                    lock_flags);
4460                                 res->change_detected = 0;
4461                         } else {
4462                                 spin_unlock_irqrestore(
4463                                                 pinstance->host->host_lock,
4464                                                 host_lock_flags);
4465                         }
4466                 }
4467         }
4468 
4469         list_for_each_entry(res, &pinstance->used_res_q, queue) {
4470 
4471                 if (res->change_detected == RES_CHANGE_ADD) {
4472 
4473                         if (!pmcraid_expose_resource(fw_version,
4474                                                      &res->cfg_entry))
4475                                 continue;
4476 
4477                         if (RES_IS_VSET(res->cfg_entry)) {
4478                                 bus = PMCRAID_VSET_BUS_ID;
4479                                 if (fw_version <= PMCRAID_FW_VERSION_1)
4480                                         target = res->cfg_entry.unique_flags1;
4481                                 else
4482                                         target = res->cfg_entry.array_id & 0xFF;
4483                                 lun = PMCRAID_VSET_LUN_ID;
4484                         } else {
4485                                 bus = PMCRAID_PHYS_BUS_ID;
4486                                 target =
4487                                      RES_TARGET(
4488                                         res->cfg_entry.resource_address);
4489                                 lun = RES_LUN(res->cfg_entry.resource_address);
4490                         }
4491 
4492                         res->change_detected = 0;
4493                         spin_unlock_irqrestore(&pinstance->resource_lock,
4494                                                 lock_flags);
4495                         scsi_add_device(pinstance->host, bus, target, lun);
4496                         spin_lock_irqsave(&pinstance->resource_lock,
4497                                            lock_flags);
4498                 }
4499         }
4500 
4501         spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
4502 }
4503 
4504 /**
4505  * pmcraid_tasklet_function - Tasklet function
4506  *
4507  * @instance: pointer to msix param structure
4508  *
4509  * Return Value
4510  *      None
4511  */
4512 static void pmcraid_tasklet_function(unsigned long instance)
4513 {
4514         struct pmcraid_isr_param *hrrq_vector;
4515         struct pmcraid_instance *pinstance;
4516         unsigned long hrrq_lock_flags;
4517         unsigned long pending_lock_flags;
4518         unsigned long host_lock_flags;
4519         spinlock_t *lockp; /* hrrq buffer lock */
4520         int id;
4521         __le32 resp;
4522 
4523         hrrq_vector = (struct pmcraid_isr_param *)instance;
4524         pinstance = hrrq_vector->drv_inst;
4525         id = hrrq_vector->hrrq_id;
4526         lockp = &(pinstance->hrrq_lock[id]);
4527 
4528         /* loop through each of the commands responded by IOA. Each HRRQ buf is
4529          * protected by its own lock. Traversals must be done within this lock
4530          * as there may be multiple tasklets running on multiple CPUs. Note
4531          * that the lock is held just for picking up the response handle and
4532          * manipulating hrrq_curr/toggle_bit values.
4533          */
4534         spin_lock_irqsave(lockp, hrrq_lock_flags);
4535 
4536         resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4537 
4538         while ((resp & HRRQ_TOGGLE_BIT) ==
4539                 pinstance->host_toggle_bit[id]) {
4540 
4541                 int cmd_index = resp >> 2;
4542                 struct pmcraid_cmd *cmd = NULL;
4543 
4544                 if (pinstance->hrrq_curr[id] < pinstance->hrrq_end[id]) {
4545                         pinstance->hrrq_curr[id]++;
4546                 } else {
4547                         pinstance->hrrq_curr[id] = pinstance->hrrq_start[id];
4548                         pinstance->host_toggle_bit[id] ^= 1u;
4549                 }
4550 
4551                 if (cmd_index >= PMCRAID_MAX_CMD) {
4552                         /* In case of invalid response handle, log message */
4553                         pmcraid_err("Invalid response handle %d\n", cmd_index);
4554                         resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4555                         continue;
4556                 }
4557 
4558                 cmd = pinstance->cmd_list[cmd_index];
4559                 spin_unlock_irqrestore(lockp, hrrq_lock_flags);
4560 
4561                 spin_lock_irqsave(&pinstance->pending_pool_lock,
4562                                    pending_lock_flags);
4563                 list_del(&cmd->free_list);
4564                 spin_unlock_irqrestore(&pinstance->pending_pool_lock,
4565                                         pending_lock_flags);
4566                 del_timer(&cmd->timer);
4567                 atomic_dec(&pinstance->outstanding_cmds);
4568 
4569                 if (cmd->cmd_done == pmcraid_ioa_reset) {
4570                         spin_lock_irqsave(pinstance->host->host_lock,
4571                                           host_lock_flags);
4572                         cmd->cmd_done(cmd);
4573                         spin_unlock_irqrestore(pinstance->host->host_lock,
4574                                                host_lock_flags);
4575                 } else if (cmd->cmd_done != NULL) {
4576                         cmd->cmd_done(cmd);
4577                 }
4578                 /* loop over until we are done with all responses */
4579                 spin_lock_irqsave(lockp, hrrq_lock_flags);
4580                 resp = le32_to_cpu(*(pinstance->hrrq_curr[id]));
4581         }
4582 
4583         spin_unlock_irqrestore(lockp, hrrq_lock_flags);
4584 }
4585 
4586 /**
4587  * pmcraid_unregister_interrupt_handler - de-register interrupts handlers
4588  * @pinstance: pointer to adapter instance structure
4589  *
4590  * This routine un-registers registered interrupt handler and
4591  * also frees irqs/vectors.
4592  *
4593  * Retun Value
4594  *      None
4595  */
4596 static
4597 void pmcraid_unregister_interrupt_handler(struct pmcraid_instance *pinstance)
4598 {
4599         int i;
4600 
4601         for (i = 0; i < pinstance->num_hrrq; i++)
4602                 free_irq(pinstance->hrrq_vector[i].vector,
4603                          &(pinstance->hrrq_vector[i]));
4604 
4605         if (pinstance->interrupt_mode) {
4606                 pci_disable_msix(pinstance->pdev);
4607                 pinstance->interrupt_mode = 0;
4608         }
4609 }
4610 
4611 /**
4612  * pmcraid_register_interrupt_handler - registers interrupt handler
4613  * @pinstance: pointer to per-adapter instance structure
4614  *
4615  * Return Value
4616  *      0 on success, non-zero error code otherwise.
4617  */
4618 static int
4619 pmcraid_register_interrupt_handler(struct pmcraid_instance *pinstance)
4620 {
4621         int rc;
4622         struct pci_dev *pdev = pinstance->pdev;
4623 
4624         if ((pmcraid_enable_msix) &&
4625                 (pci_find_capability(pdev, PCI_CAP_ID_MSIX))) {
4626                 int num_hrrq = PMCRAID_NUM_MSIX_VECTORS;
4627                 struct msix_entry entries[PMCRAID_NUM_MSIX_VECTORS];
4628                 int i;
4629                 for (i = 0; i < PMCRAID_NUM_MSIX_VECTORS; i++)
4630                         entries[i].entry = i;
4631 
4632                 num_hrrq = pci_enable_msix_range(pdev, entries, 1, num_hrrq);
4633                 if (num_hrrq < 0)
4634                         goto pmcraid_isr_legacy;
4635 
4636                 for (i = 0; i < num_hrrq; i++) {
4637                         pinstance->hrrq_vector[i].hrrq_id = i;
4638                         pinstance->hrrq_vector[i].drv_inst = pinstance;
4639                         pinstance->hrrq_vector[i].vector = entries[i].vector;
4640                         rc = request_irq(pinstance->hrrq_vector[i].vector,
4641                                         pmcraid_isr_msix, 0,
4642                                         PMCRAID_DRIVER_NAME,
4643                                         &(pinstance->hrrq_vector[i]));
4644 
4645                         if (rc) {
4646                                 int j;
4647                                 for (j = 0; j < i; j++)
4648                                         free_irq(entries[j].vector,
4649                                                  &(pinstance->hrrq_vector[j]));
4650                                 pci_disable_msix(pdev);
4651                                 goto pmcraid_isr_legacy;
4652                         }
4653                 }
4654 
4655                 pinstance->num_hrrq = num_hrrq;
4656                 pinstance->interrupt_mode = 1;
4657                 iowrite32(DOORBELL_INTR_MODE_MSIX,
4658                           pinstance->int_regs.host_ioa_interrupt_reg);
4659                 ioread32(pinstance->int_regs.host_ioa_interrupt_reg);
4660                 goto pmcraid_isr_out;
4661         }
4662 
4663 pmcraid_isr_legacy:
4664         /* If MSI-X registration failed fallback to legacy mode, where
4665          * only one hrrq entry will be used
4666          */
4667         pinstance->hrrq_vector[0].hrrq_id = 0;
4668         pinstance->hrrq_vector[0].drv_inst = pinstance;
4669         pinstance->hrrq_vector[0].vector = pdev->irq;
4670         pinstance->num_hrrq = 1;
4671 
4672         rc = request_irq(pdev->irq, pmcraid_isr, IRQF_SHARED,
4673                          PMCRAID_DRIVER_NAME, &pinstance->hrrq_vector[0]);
4674 pmcraid_isr_out:
4675         return rc;
4676 }
4677 
4678 /**
4679  * pmcraid_release_cmd_blocks - release buufers allocated for command blocks
4680  * @pinstance: per adapter instance structure pointer
4681  * @max_index: number of buffer blocks to release
4682  *
4683  * Return Value
4684  *  None
4685  */
4686 static void
4687 pmcraid_release_cmd_blocks(struct pmcraid_instance *pinstance, int max_index)
4688 {
4689         int i;
4690         for (i = 0; i < max_index; i++) {
4691                 kmem_cache_free(pinstance->cmd_cachep, pinstance->cmd_list[i]);
4692                 pinstance->cmd_list[i] = NULL;
4693         }
4694         kmem_cache_destroy(pinstance->cmd_cachep);
4695         pinstance->cmd_cachep = NULL;
4696 }
4697 
4698 /**
4699  * pmcraid_release_control_blocks - releases buffers alloced for control blocks
4700  * @pinstance: pointer to per adapter instance structure
4701  * @max_index: number of buffers (from 0 onwards) to release
4702  *
4703  * This function assumes that the command blocks for which control blocks are
4704  * linked are not released.
4705  *
4706  * Return Value
4707  *       None
4708  */
4709 static void
4710 pmcraid_release_control_blocks(
4711         struct pmcraid_instance *pinstance,
4712         int max_index
4713 )
4714 {
4715         int i;
4716 
4717         if (pinstance->control_pool == NULL)
4718                 return;
4719 
4720         for (i = 0; i < max_index; i++) {
4721                 pci_pool_free(pinstance->control_pool,
4722                               pinstance->cmd_list[i]->ioa_cb,
4723                               pinstance->cmd_list[i]->ioa_cb_bus_addr);
4724                 pinstance->cmd_list[i]->ioa_cb = NULL;
4725                 pinstance->cmd_list[i]->ioa_cb_bus_addr = 0;
4726         }
4727         pci_pool_destroy(pinstance->control_pool);
4728         pinstance->control_pool = NULL;
4729 }
4730 
4731 /**
4732  * pmcraid_allocate_cmd_blocks - allocate memory for cmd block structures
4733  * @pinstance - pointer to per adapter instance structure
4734  *
4735  * Allocates memory for command blocks using kernel slab allocator.
4736  *
4737  * Return Value
4738  *      0 in case of success; -ENOMEM in case of failure
4739  */
4740 static int pmcraid_allocate_cmd_blocks(struct pmcraid_instance *pinstance)
4741 {
4742         int i;
4743 
4744         sprintf(pinstance->cmd_pool_name, "pmcraid_cmd_pool_%d",
4745                 pinstance->host->unique_id);
4746 
4747 
4748         pinstance->cmd_cachep = kmem_cache_create(
4749                                         pinstance->cmd_pool_name,
4750                                         sizeof(struct pmcraid_cmd), 0,
4751                                         SLAB_HWCACHE_ALIGN, NULL);
4752         if (!pinstance->cmd_cachep)
4753                 return -ENOMEM;
4754 
4755         for (i = 0; i < PMCRAID_MAX_CMD; i++) {
4756                 pinstance->cmd_list[i] =
4757                         kmem_cache_alloc(pinstance->cmd_cachep, GFP_KERNEL);
4758                 if (!pinstance->cmd_list[i]) {
4759                         pmcraid_release_cmd_blocks(pinstance, i);
4760                         return -ENOMEM;
4761                 }
4762         }
4763         return 0;
4764 }
4765 
4766 /**
4767  * pmcraid_allocate_control_blocks - allocates memory control blocks
4768  * @pinstance : pointer to per adapter instance structure
4769  *
4770  * This function allocates PCI memory for DMAable buffers like IOARCB, IOADLs
4771  * and IOASAs. This is called after command blocks are already allocated.
4772  *
4773  * Return Value
4774  *  0 in case it can allocate all control blocks, otherwise -ENOMEM
4775  */
4776 static int pmcraid_allocate_control_blocks(struct pmcraid_instance *pinstance)
4777 {
4778         int i;
4779 
4780         sprintf(pinstance->ctl_pool_name, "pmcraid_control_pool_%d",
4781                 pinstance->host->unique_id);
4782 
4783         pinstance->control_pool =
4784                 pci_pool_create(pinstance->ctl_pool_name,
4785                                 pinstance->pdev,
4786                                 sizeof(struct pmcraid_control_block),
4787                                 PMCRAID_IOARCB_ALIGNMENT, 0);
4788 
4789         if (!pinstance->control_pool)
4790                 return -ENOMEM;
4791 
4792         for (i = 0; i < PMCRAID_MAX_CMD; i++) {
4793                 pinstance->cmd_list[i]->ioa_cb =
4794                         pci_pool_alloc(
4795                                 pinstance->control_pool,
4796                                 GFP_KERNEL,
4797                                 &(pinstance->cmd_list[i]->ioa_cb_bus_addr));
4798 
4799                 if (!pinstance->cmd_list[i]->ioa_cb) {
4800                         pmcraid_release_control_blocks(pinstance, i);
4801                         return -ENOMEM;
4802                 }
4803                 memset(pinstance->cmd_list[i]->ioa_cb, 0,
4804                         sizeof(struct pmcraid_control_block));
4805         }
4806         return 0;
4807 }
4808 
4809 /**
4810  * pmcraid_release_host_rrqs - release memory allocated for hrrq buffer(s)
4811  * @pinstance: pointer to per adapter instance structure
4812  * @maxindex: size of hrrq buffer pointer array
4813  *
4814  * Return Value
4815  *      None
4816  */
4817 static void
4818 pmcraid_release_host_rrqs(struct pmcraid_instance *pinstance, int maxindex)
4819 {
4820         int i;
4821         for (i = 0; i < maxindex; i++) {
4822 
4823                 pci_free_consistent(pinstance->pdev,
4824                                     HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD,
4825                                     pinstance->hrrq_start[i],
4826                                     pinstance->hrrq_start_bus_addr[i]);
4827 
4828                 /* reset pointers and toggle bit to zeros */
4829                 pinstance->hrrq_start[i] = NULL;
4830                 pinstance->hrrq_start_bus_addr[i] = 0;
4831                 pinstance->host_toggle_bit[i] = 0;
4832         }
4833 }
4834 
4835 /**
4836  * pmcraid_allocate_host_rrqs - Allocate and initialize host RRQ buffers
4837  * @pinstance: pointer to per adapter instance structure
4838  *
4839  * Return value
4840  *      0 hrrq buffers are allocated, -ENOMEM otherwise.
4841  */
4842 static int pmcraid_allocate_host_rrqs(struct pmcraid_instance *pinstance)
4843 {
4844         int i, buffer_size;
4845 
4846         buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
4847 
4848         for (i = 0; i < pinstance->num_hrrq; i++) {
4849                 pinstance->hrrq_start[i] =
4850                         pci_alloc_consistent(
4851                                         pinstance->pdev,
4852                                         buffer_size,
4853                                         &(pinstance->hrrq_start_bus_addr[i]));
4854 
4855                 if (pinstance->hrrq_start[i] == 0) {
4856                         pmcraid_err("pci_alloc failed for hrrq vector : %d\n",
4857                                     i);
4858                         pmcraid_release_host_rrqs(pinstance, i);
4859                         return -ENOMEM;
4860                 }
4861 
4862                 memset(pinstance->hrrq_start[i], 0, buffer_size);
4863                 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
4864                 pinstance->hrrq_end[i] =
4865                         pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
4866                 pinstance->host_toggle_bit[i] = 1;
4867                 spin_lock_init(&pinstance->hrrq_lock[i]);
4868         }
4869         return 0;
4870 }
4871 
4872 /**
4873  * pmcraid_release_hcams - release HCAM buffers
4874  *
4875  * @pinstance: pointer to per adapter instance structure
4876  *
4877  * Return value
4878  *  none
4879  */
4880 static void pmcraid_release_hcams(struct pmcraid_instance *pinstance)
4881 {
4882         if (pinstance->ccn.msg != NULL) {
4883                 pci_free_consistent(pinstance->pdev,
4884                                     PMCRAID_AEN_HDR_SIZE +
4885                                     sizeof(struct pmcraid_hcam_ccn_ext),
4886                                     pinstance->ccn.msg,
4887                                     pinstance->ccn.baddr);
4888 
4889                 pinstance->ccn.msg = NULL;
4890                 pinstance->ccn.hcam = NULL;
4891                 pinstance->ccn.baddr = 0;
4892         }
4893 
4894         if (pinstance->ldn.msg != NULL) {
4895                 pci_free_consistent(pinstance->pdev,
4896                                     PMCRAID_AEN_HDR_SIZE +
4897                                     sizeof(struct pmcraid_hcam_ldn),
4898                                     pinstance->ldn.msg,
4899                                     pinstance->ldn.baddr);
4900 
4901                 pinstance->ldn.msg = NULL;
4902                 pinstance->ldn.hcam = NULL;
4903                 pinstance->ldn.baddr = 0;
4904         }
4905 }
4906 
4907 /**
4908  * pmcraid_allocate_hcams - allocates HCAM buffers
4909  * @pinstance : pointer to per adapter instance structure
4910  *
4911  * Return Value:
4912  *   0 in case of successful allocation, non-zero otherwise
4913  */
4914 static int pmcraid_allocate_hcams(struct pmcraid_instance *pinstance)
4915 {
4916         pinstance->ccn.msg = pci_alloc_consistent(
4917                                         pinstance->pdev,
4918                                         PMCRAID_AEN_HDR_SIZE +
4919                                         sizeof(struct pmcraid_hcam_ccn_ext),
4920                                         &(pinstance->ccn.baddr));
4921 
4922         pinstance->ldn.msg = pci_alloc_consistent(
4923                                         pinstance->pdev,
4924                                         PMCRAID_AEN_HDR_SIZE +
4925                                         sizeof(struct pmcraid_hcam_ldn),
4926                                         &(pinstance->ldn.baddr));
4927 
4928         if (pinstance->ldn.msg == NULL || pinstance->ccn.msg == NULL) {
4929                 pmcraid_release_hcams(pinstance);
4930         } else {
4931                 pinstance->ccn.hcam =
4932                         (void *)pinstance->ccn.msg + PMCRAID_AEN_HDR_SIZE;
4933                 pinstance->ldn.hcam =
4934                         (void *)pinstance->ldn.msg + PMCRAID_AEN_HDR_SIZE;
4935 
4936                 atomic_set(&pinstance->ccn.ignore, 0);
4937                 atomic_set(&pinstance->ldn.ignore, 0);
4938         }
4939 
4940         return (pinstance->ldn.msg == NULL) ? -ENOMEM : 0;
4941 }
4942 
4943 /**
4944  * pmcraid_release_config_buffers - release config.table buffers
4945  * @pinstance: pointer to per adapter instance structure
4946  *
4947  * Return Value
4948  *       none
4949  */
4950 static void pmcraid_release_config_buffers(struct pmcraid_instance *pinstance)
4951 {
4952         if (pinstance->cfg_table != NULL &&
4953             pinstance->cfg_table_bus_addr != 0) {
4954                 pci_free_consistent(pinstance->pdev,
4955                                     sizeof(struct pmcraid_config_table),
4956                                     pinstance->cfg_table,
4957                                     pinstance->cfg_table_bus_addr);
4958                 pinstance->cfg_table = NULL;
4959                 pinstance->cfg_table_bus_addr = 0;
4960         }
4961 
4962         if (pinstance->res_entries != NULL) {
4963                 int i;
4964 
4965                 for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
4966                         list_del(&pinstance->res_entries[i].queue);
4967                 kfree(pinstance->res_entries);
4968                 pinstance->res_entries = NULL;
4969         }
4970 
4971         pmcraid_release_hcams(pinstance);
4972 }
4973 
4974 /**
4975  * pmcraid_allocate_config_buffers - allocates DMAable memory for config table
4976  * @pinstance : pointer to per adapter instance structure
4977  *
4978  * Return Value
4979  *      0 for successful allocation, -ENOMEM for any failure
4980  */
4981 static int pmcraid_allocate_config_buffers(struct pmcraid_instance *pinstance)
4982 {
4983         int i;
4984 
4985         pinstance->res_entries =
4986                         kzalloc(sizeof(struct pmcraid_resource_entry) *
4987                                 PMCRAID_MAX_RESOURCES, GFP_KERNEL);
4988 
4989         if (NULL == pinstance->res_entries) {
4990                 pmcraid_err("failed to allocate memory for resource table\n");
4991                 return -ENOMEM;
4992         }
4993 
4994         for (i = 0; i < PMCRAID_MAX_RESOURCES; i++)
4995                 list_add_tail(&pinstance->res_entries[i].queue,
4996                               &pinstance->free_res_q);
4997 
4998         pinstance->cfg_table =
4999                 pci_alloc_consistent(pinstance->pdev,
5000                                      sizeof(struct pmcraid_config_table),
5001                                      &pinstance->cfg_table_bus_addr);
5002 
5003         if (NULL == pinstance->cfg_table) {
5004                 pmcraid_err("couldn't alloc DMA memory for config table\n");
5005                 pmcraid_release_config_buffers(pinstance);
5006                 return -ENOMEM;
5007         }
5008 
5009         if (pmcraid_allocate_hcams(pinstance)) {
5010                 pmcraid_err("could not alloc DMA memory for HCAMS\n");
5011                 pmcraid_release_config_buffers(pinstance);
5012                 return -ENOMEM;
5013         }
5014 
5015         return 0;
5016 }
5017 
5018 /**
5019  * pmcraid_init_tasklets - registers tasklets for response handling
5020  *
5021  * @pinstance: pointer adapter instance structure
5022  *
5023  * Return value
5024  *      none
5025  */
5026 static void pmcraid_init_tasklets(struct pmcraid_instance *pinstance)
5027 {
5028         int i;
5029         for (i = 0; i < pinstance->num_hrrq; i++)
5030                 tasklet_init(&pinstance->isr_tasklet[i],
5031                              pmcraid_tasklet_function,
5032                              (unsigned long)&pinstance->hrrq_vector[i]);
5033 }
5034 
5035 /**
5036  * pmcraid_kill_tasklets - destroys tasklets registered for response handling
5037  *
5038  * @pinstance: pointer to adapter instance structure
5039  *
5040  * Return value
5041  *      none
5042  */
5043 static void pmcraid_kill_tasklets(struct pmcraid_instance *pinstance)
5044 {
5045         int i;
5046         for (i = 0; i < pinstance->num_hrrq; i++)
5047                 tasklet_kill(&pinstance->isr_tasklet[i]);
5048 }
5049 
5050 /**
5051  * pmcraid_release_buffers - release per-adapter buffers allocated
5052  *
5053  * @pinstance: pointer to adapter soft state
5054  *
5055  * Return Value
5056  *      none
5057  */
5058 static void pmcraid_release_buffers(struct pmcraid_instance *pinstance)
5059 {
5060         pmcraid_release_config_buffers(pinstance);
5061         pmcraid_release_control_blocks(pinstance, PMCRAID_MAX_CMD);
5062         pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5063         pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5064 
5065         if (pinstance->inq_data != NULL) {
5066                 pci_free_consistent(pinstance->pdev,
5067                                     sizeof(struct pmcraid_inquiry_data),
5068                                     pinstance->inq_data,
5069                                     pinstance->inq_data_baddr);
5070 
5071                 pinstance->inq_data = NULL;
5072                 pinstance->inq_data_baddr = 0;
5073         }
5074 
5075         if (pinstance->timestamp_data != NULL) {
5076                 pci_free_consistent(pinstance->pdev,
5077                                     sizeof(struct pmcraid_timestamp_data),
5078                                     pinstance->timestamp_data,
5079                                     pinstance->timestamp_data_baddr);
5080 
5081                 pinstance->timestamp_data = NULL;
5082                 pinstance->timestamp_data_baddr = 0;
5083         }
5084 }
5085 
5086 /**
5087  * pmcraid_init_buffers - allocates memory and initializes various structures
5088  * @pinstance: pointer to per adapter instance structure
5089  *
5090  * This routine pre-allocates memory based on the type of block as below:
5091  * cmdblocks(PMCRAID_MAX_CMD): kernel memory using kernel's slab_allocator,
5092  * IOARCBs(PMCRAID_MAX_CMD)  : DMAable memory, using pci pool allocator
5093  * config-table entries      : DMAable memory using pci_alloc_consistent
5094  * HostRRQs                  : DMAable memory, using pci_alloc_consistent
5095  *
5096  * Return Value
5097  *       0 in case all of the blocks are allocated, -ENOMEM otherwise.
5098  */
5099 static int pmcraid_init_buffers(struct pmcraid_instance *pinstance)
5100 {
5101         int i;
5102 
5103         if (pmcraid_allocate_host_rrqs(pinstance)) {
5104                 pmcraid_err("couldn't allocate memory for %d host rrqs\n",
5105                              pinstance->num_hrrq);
5106                 return -ENOMEM;
5107         }
5108 
5109         if (pmcraid_allocate_config_buffers(pinstance)) {
5110                 pmcraid_err("couldn't allocate memory for config buffers\n");
5111                 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5112                 return -ENOMEM;
5113         }
5114 
5115         if (pmcraid_allocate_cmd_blocks(pinstance)) {
5116                 pmcraid_err("couldn't allocate memory for cmd blocks\n");
5117                 pmcraid_release_config_buffers(pinstance);
5118                 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5119                 return -ENOMEM;
5120         }
5121 
5122         if (pmcraid_allocate_control_blocks(pinstance)) {
5123                 pmcraid_err("couldn't allocate memory control blocks\n");
5124                 pmcraid_release_config_buffers(pinstance);
5125                 pmcraid_release_cmd_blocks(pinstance, PMCRAID_MAX_CMD);
5126                 pmcraid_release_host_rrqs(pinstance, pinstance->num_hrrq);
5127                 return -ENOMEM;
5128         }
5129 
5130         /* allocate DMAable memory for page D0 INQUIRY buffer */
5131         pinstance->inq_data = pci_alloc_consistent(
5132                                         pinstance->pdev,
5133                                         sizeof(struct pmcraid_inquiry_data),
5134                                         &pinstance->inq_data_baddr);
5135 
5136         if (pinstance->inq_data == NULL) {
5137                 pmcraid_err("couldn't allocate DMA memory for INQUIRY\n");
5138                 pmcraid_release_buffers(pinstance);
5139                 return -ENOMEM;
5140         }
5141 
5142         /* allocate DMAable memory for set timestamp data buffer */
5143         pinstance->timestamp_data = pci_alloc_consistent(
5144                                         pinstance->pdev,
5145                                         sizeof(struct pmcraid_timestamp_data),
5146                                         &pinstance->timestamp_data_baddr);
5147 
5148         if (pinstance->timestamp_data == NULL) {
5149                 pmcraid_err("couldn't allocate DMA memory for \
5150                                 set time_stamp \n");
5151                 pmcraid_release_buffers(pinstance);
5152                 return -ENOMEM;
5153         }
5154 
5155 
5156         /* Initialize all the command blocks and add them to free pool. No
5157          * need to lock (free_pool_lock) as this is done in initialization
5158          * itself
5159          */
5160         for (i = 0; i < PMCRAID_MAX_CMD; i++) {
5161                 struct pmcraid_cmd *cmdp = pinstance->cmd_list[i];
5162                 pmcraid_init_cmdblk(cmdp, i);
5163                 cmdp->drv_inst = pinstance;
5164                 list_add_tail(&cmdp->free_list, &pinstance->free_cmd_pool);
5165         }
5166 
5167         return 0;
5168 }
5169 
5170 /**
5171  * pmcraid_reinit_buffers - resets various buffer pointers
5172  * @pinstance: pointer to adapter instance
5173  * Return value
5174  *      none
5175  */
5176 static void pmcraid_reinit_buffers(struct pmcraid_instance *pinstance)
5177 {
5178         int i;
5179         int buffer_size = HRRQ_ENTRY_SIZE * PMCRAID_MAX_CMD;
5180 
5181         for (i = 0; i < pinstance->num_hrrq; i++) {
5182                 memset(pinstance->hrrq_start[i], 0, buffer_size);
5183                 pinstance->hrrq_curr[i] = pinstance->hrrq_start[i];
5184                 pinstance->hrrq_end[i] =
5185                         pinstance->hrrq_start[i] + PMCRAID_MAX_CMD - 1;
5186                 pinstance->host_toggle_bit[i] = 1;
5187         }
5188 }
5189 
5190 /**
5191  * pmcraid_init_instance - initialize per instance data structure
5192  * @pdev: pointer to pci device structure
5193  * @host: pointer to Scsi_Host structure
5194  * @mapped_pci_addr: memory mapped IOA configuration registers
5195  *
5196  * Return Value
5197  *       0 on success, non-zero in case of any failure
5198  */
5199 static int pmcraid_init_instance(struct pci_dev *pdev, struct Scsi_Host *host,
5200                                  void __iomem *mapped_pci_addr)
5201 {
5202         struct pmcraid_instance *pinstance =
5203                 (struct pmcraid_instance *)host->hostdata;
5204 
5205         pinstance->host = host;
5206         pinstance->pdev = pdev;
5207 
5208         /* Initialize register addresses */
5209         pinstance->mapped_dma_addr = mapped_pci_addr;
5210 
5211         /* Initialize chip-specific details */
5212         {
5213                 struct pmcraid_chip_details *chip_cfg = pinstance->chip_cfg;
5214                 struct pmcraid_interrupts *pint_regs = &pinstance->int_regs;
5215 
5216                 pinstance->ioarrin = mapped_pci_addr + chip_cfg->ioarrin;
5217 
5218                 pint_regs->ioa_host_interrupt_reg =
5219                         mapped_pci_addr + chip_cfg->ioa_host_intr;
5220                 pint_regs->ioa_host_interrupt_clr_reg =
5221                         mapped_pci_addr + chip_cfg->ioa_host_intr_clr;
5222                 pint_regs->ioa_host_msix_interrupt_reg =
5223                         mapped_pci_addr + chip_cfg->ioa_host_msix_intr;
5224                 pint_regs->host_ioa_interrupt_reg =
5225                         mapped_pci_addr + chip_cfg->host_ioa_intr;
5226                 pint_regs->host_ioa_interrupt_clr_reg =
5227                         mapped_pci_addr + chip_cfg->host_ioa_intr_clr;
5228 
5229                 /* Current version of firmware exposes interrupt mask set
5230                  * and mask clr registers through memory mapped bar0.
5231                  */
5232                 pinstance->mailbox = mapped_pci_addr + chip_cfg->mailbox;
5233                 pinstance->ioa_status = mapped_pci_addr + chip_cfg->ioastatus;
5234                 pint_regs->ioa_host_interrupt_mask_reg =
5235                         mapped_pci_addr + chip_cfg->ioa_host_mask;
5236                 pint_regs->ioa_host_interrupt_mask_clr_reg =
5237                         mapped_pci_addr + chip_cfg->ioa_host_mask_clr;
5238                 pint_regs->global_interrupt_mask_reg =
5239                         mapped_pci_addr + chip_cfg->global_intr_mask;
5240         };
5241 
5242         pinstance->ioa_reset_attempts = 0;
5243         init_waitqueue_head(&pinstance->reset_wait_q);
5244 
5245         atomic_set(&pinstance->outstanding_cmds, 0);
5246         atomic_set(&pinstance->last_message_id, 0);
5247         atomic_set(&pinstance->expose_resources, 0);
5248 
5249         INIT_LIST_HEAD(&pinstance->free_res_q);
5250         INIT_LIST_HEAD(&pinstance->used_res_q);
5251         INIT_LIST_HEAD(&pinstance->free_cmd_pool);
5252         INIT_LIST_HEAD(&pinstance->pending_cmd_pool);
5253 
5254         spin_lock_init(&pinstance->free_pool_lock);
5255         spin_lock_init(&pinstance->pending_pool_lock);
5256         spin_lock_init(&pinstance->resource_lock);
5257         mutex_init(&pinstance->aen_queue_lock);
5258 
5259         /* Work-queue (Shared) for deferred processing error handling */
5260         INIT_WORK(&pinstance->worker_q, pmcraid_worker_function);
5261 
5262         /* Initialize the default log_level */
5263         pinstance->current_log_level = pmcraid_log_level;
5264 
5265         /* Setup variables required for reset engine */
5266         pinstance->ioa_state = IOA_STATE_UNKNOWN;
5267         pinstance->reset_cmd = NULL;
5268         return 0;
5269 }
5270 
5271 /**
5272  * pmcraid_shutdown - shutdown adapter controller.
5273  * @pdev: pci device struct
5274  *
5275  * Issues an adapter shutdown to the card waits for its completion
5276  *
5277  * Return value
5278  *        none
5279  */
5280 static void pmcraid_shutdown(struct pci_dev *pdev)
5281 {
5282         struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5283         pmcraid_reset_bringdown(pinstance);
5284 }
5285 
5286 
5287 /**
5288  * pmcraid_get_minor - returns unused minor number from minor number bitmap
5289  */
5290 static unsigned short pmcraid_get_minor(void)
5291 {
5292         int minor;
5293 
5294         minor = find_first_zero_bit(pmcraid_minor, sizeof(pmcraid_minor));
5295         __set_bit(minor, pmcraid_minor);
5296         return minor;
5297 }
5298 
5299 /**
5300  * pmcraid_release_minor - releases given minor back to minor number bitmap
5301  */
5302 static void pmcraid_release_minor(unsigned short minor)
5303 {
5304         __clear_bit(minor, pmcraid_minor);
5305 }
5306 
5307 /**
5308  * pmcraid_setup_chrdev - allocates a minor number and registers a char device
5309  *
5310  * @pinstance: pointer to adapter instance for which to register device
5311  *
5312  * Return value
5313  *      0 in case of success, otherwise non-zero
5314  */
5315 static int pmcraid_setup_chrdev(struct pmcraid_instance *pinstance)
5316 {
5317         int minor;
5318         int error;
5319 
5320         minor = pmcraid_get_minor();
5321         cdev_init(&pinstance->cdev, &pmcraid_fops);
5322         pinstance->cdev.owner = THIS_MODULE;
5323 
5324         error = cdev_add(&pinstance->cdev, MKDEV(pmcraid_major, minor), 1);
5325 
5326         if (error)
5327                 pmcraid_release_minor(minor);
5328         else
5329                 device_create(pmcraid_class, NULL, MKDEV(pmcraid_major, minor),
5330                               NULL, "%s%u", PMCRAID_DEVFILE, minor);
5331         return error;
5332 }
5333 
5334 /**
5335  * pmcraid_release_chrdev - unregisters per-adapter management interface
5336  *
5337  * @pinstance: pointer to adapter instance structure
5338  *
5339  * Return value
5340  *  none
5341  */
5342 static void pmcraid_release_chrdev(struct pmcraid_instance *pinstance)
5343 {
5344         pmcraid_release_minor(MINOR(pinstance->cdev.dev));
5345         device_destroy(pmcraid_class,
5346                        MKDEV(pmcraid_major, MINOR(pinstance->cdev.dev)));
5347         cdev_del(&pinstance->cdev);
5348 }
5349 
5350 /**
5351  * pmcraid_remove - IOA hot plug remove entry point
5352  * @pdev: pci device struct
5353  *
5354  * Return value
5355  *        none
5356  */
5357 static void pmcraid_remove(struct pci_dev *pdev)
5358 {
5359         struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5360 
5361         /* remove the management interface (/dev file) for this device */
5362         pmcraid_release_chrdev(pinstance);
5363 
5364         /* remove host template from scsi midlayer */
5365         scsi_remove_host(pinstance->host);
5366 
5367         /* block requests from mid-layer */
5368         scsi_block_requests(pinstance->host);
5369 
5370         /* initiate shutdown adapter */
5371         pmcraid_shutdown(pdev);
5372 
5373         pmcraid_disable_interrupts(pinstance, ~0);
5374         flush_work(&pinstance->worker_q);
5375 
5376         pmcraid_kill_tasklets(pinstance);
5377         pmcraid_unregister_interrupt_handler(pinstance);
5378         pmcraid_release_buffers(pinstance);
5379         iounmap(pinstance->mapped_dma_addr);
5380         pci_release_regions(pdev);
5381         scsi_host_put(pinstance->host);
5382         pci_disable_device(pdev);
5383 
5384         return;
5385 }
5386 
5387 #ifdef CONFIG_PM
5388 /**
5389  * pmcraid_suspend - driver suspend entry point for power management
5390  * @pdev:   PCI device structure
5391  * @state:  PCI power state to suspend routine
5392  *
5393  * Return Value - 0 always
5394  */
5395 static int pmcraid_suspend(struct pci_dev *pdev, pm_message_t state)
5396 {
5397         struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5398 
5399         pmcraid_shutdown(pdev);
5400         pmcraid_disable_interrupts(pinstance, ~0);
5401         pmcraid_kill_tasklets(pinstance);
5402         pci_set_drvdata(pinstance->pdev, pinstance);
5403         pmcraid_unregister_interrupt_handler(pinstance);
5404         pci_save_state(pdev);
5405         pci_disable_device(pdev);
5406         pci_set_power_state(pdev, pci_choose_state(pdev, state));
5407 
5408         return 0;
5409 }
5410 
5411 /**
5412  * pmcraid_resume - driver resume entry point PCI power management
5413  * @pdev: PCI device structure
5414  *
5415  * Return Value - 0 in case of success. Error code in case of any failure
5416  */
5417 static int pmcraid_resume(struct pci_dev *pdev)
5418 {
5419         struct pmcraid_instance *pinstance = pci_get_drvdata(pdev);
5420         struct Scsi_Host *host = pinstance->host;
5421         int rc;
5422 
5423         pci_set_power_state(pdev, PCI_D0);
5424         pci_enable_wake(pdev, PCI_D0, 0);
5425         pci_restore_state(pdev);
5426 
5427         rc = pci_enable_device(pdev);
5428 
5429         if (rc) {
5430                 dev_err(&pdev->dev, "resume: Enable device failed\n");
5431                 return rc;
5432         }
5433 
5434         pci_set_master(pdev);
5435 
5436         if ((sizeof(dma_addr_t) == 4) ||
5437              pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
5438                 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
5439 
5440         if (rc == 0)
5441                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
5442 
5443         if (rc != 0) {
5444                 dev_err(&pdev->dev, "resume: Failed to set PCI DMA mask\n");
5445                 goto disable_device;
5446         }
5447 
5448         pmcraid_disable_interrupts(pinstance, ~0);
5449         atomic_set(&pinstance->outstanding_cmds, 0);
5450         rc = pmcraid_register_interrupt_handler(pinstance);
5451 
5452         if (rc) {
5453                 dev_err(&pdev->dev,
5454                         "resume: couldn't register interrupt handlers\n");
5455                 rc = -ENODEV;
5456                 goto release_host;
5457         }
5458 
5459         pmcraid_init_tasklets(pinstance);
5460         pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5461 
5462         /* Start with hard reset sequence which brings up IOA to operational
5463          * state as well as completes the reset sequence.
5464          */
5465         pinstance->ioa_hard_reset = 1;
5466 
5467         /* Start IOA firmware initialization and bring card to Operational
5468          * state.
5469          */
5470         if (pmcraid_reset_bringup(pinstance)) {
5471                 dev_err(&pdev->dev, "couldn't initialize IOA\n");
5472                 rc = -ENODEV;
5473                 goto release_tasklets;
5474         }
5475 
5476         return 0;
5477 
5478 release_tasklets:
5479         pmcraid_disable_interrupts(pinstance, ~0);
5480         pmcraid_kill_tasklets(pinstance);
5481         pmcraid_unregister_interrupt_handler(pinstance);
5482 
5483 release_host:
5484         scsi_host_put(host);
5485 
5486 disable_device:
5487         pci_disable_device(pdev);
5488 
5489         return rc;
5490 }
5491 
5492 #else
5493 
5494 #define pmcraid_suspend NULL
5495 #define pmcraid_resume  NULL
5496 
5497 #endif /* CONFIG_PM */
5498 
5499 /**
5500  * pmcraid_complete_ioa_reset - Called by either timer or tasklet during
5501  *                              completion of the ioa reset
5502  * @cmd: pointer to reset command block
5503  */
5504 static void pmcraid_complete_ioa_reset(struct pmcraid_cmd *cmd)
5505 {
5506         struct pmcraid_instance *pinstance = cmd->drv_inst;
5507         unsigned long flags;
5508 
5509         spin_lock_irqsave(pinstance->host->host_lock, flags);
5510         pmcraid_ioa_reset(cmd);
5511         spin_unlock_irqrestore(pinstance->host->host_lock, flags);
5512         scsi_unblock_requests(pinstance->host);
5513         schedule_work(&pinstance->worker_q);
5514 }
5515 
5516 /**
5517  * pmcraid_set_supported_devs - sends SET SUPPORTED DEVICES to IOAFP
5518  *
5519  * @cmd: pointer to pmcraid_cmd structure
5520  *
5521  * Return Value
5522  *  0 for success or non-zero for failure cases
5523  */
5524 static void pmcraid_set_supported_devs(struct pmcraid_cmd *cmd)
5525 {
5526         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5527         void (*cmd_done) (struct pmcraid_cmd *) = pmcraid_complete_ioa_reset;
5528 
5529         pmcraid_reinit_cmdblk(cmd);
5530 
5531         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5532         ioarcb->request_type = REQ_TYPE_IOACMD;
5533         ioarcb->cdb[0] = PMCRAID_SET_SUPPORTED_DEVICES;
5534         ioarcb->cdb[1] = ALL_DEVICES_SUPPORTED;
5535 
5536         /* If this was called as part of resource table reinitialization due to
5537          * lost CCN, it is enough to return the command block back to free pool
5538          * as part of set_supported_devs completion function.
5539          */
5540         if (cmd->drv_inst->reinit_cfg_table) {
5541                 cmd->drv_inst->reinit_cfg_table = 0;
5542                 cmd->release = 1;
5543                 cmd_done = pmcraid_reinit_cfgtable_done;
5544         }
5545 
5546         /* we will be done with the reset sequence after set supported devices,
5547          * setup the done function to return the command block back to free
5548          * pool
5549          */
5550         pmcraid_send_cmd(cmd,
5551                          cmd_done,
5552                          PMCRAID_SET_SUP_DEV_TIMEOUT,
5553                          pmcraid_timeout_handler);
5554         return;
5555 }
5556 
5557 /**
5558  * pmcraid_set_timestamp - set the timestamp to IOAFP
5559  *
5560  * @cmd: pointer to pmcraid_cmd structure
5561  *
5562  * Return Value
5563  *  0 for success or non-zero for failure cases
5564  */
5565 static void pmcraid_set_timestamp(struct pmcraid_cmd *cmd)
5566 {
5567         struct pmcraid_instance *pinstance = cmd->drv_inst;
5568         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5569         __be32 time_stamp_len = cpu_to_be32(PMCRAID_TIMESTAMP_LEN);
5570         struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
5571 
5572         struct timeval tv;
5573         __le64 timestamp;
5574 
5575         do_gettimeofday(&tv);
5576         timestamp = tv.tv_sec * 1000;
5577 
5578         pinstance->timestamp_data->timestamp[0] = (__u8)(timestamp);
5579         pinstance->timestamp_data->timestamp[1] = (__u8)((timestamp) >> 8);
5580         pinstance->timestamp_data->timestamp[2] = (__u8)((timestamp) >> 16);
5581         pinstance->timestamp_data->timestamp[3] = (__u8)((timestamp) >> 24);
5582         pinstance->timestamp_data->timestamp[4] = (__u8)((timestamp) >> 32);
5583         pinstance->timestamp_data->timestamp[5] = (__u8)((timestamp)  >> 40);
5584 
5585         pmcraid_reinit_cmdblk(cmd);
5586         ioarcb->request_type = REQ_TYPE_SCSI;
5587         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5588         ioarcb->cdb[0] = PMCRAID_SCSI_SET_TIMESTAMP;
5589         ioarcb->cdb[1] = PMCRAID_SCSI_SERVICE_ACTION;
5590         memcpy(&(ioarcb->cdb[6]), &time_stamp_len, sizeof(time_stamp_len));
5591 
5592         ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
5593                                         offsetof(struct pmcraid_ioarcb,
5594                                                 add_data.u.ioadl[0]));
5595         ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
5596         ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
5597 
5598         ioarcb->request_flags0 |= NO_LINK_DESCS;
5599         ioarcb->request_flags0 |= TRANSFER_DIR_WRITE;
5600         ioarcb->data_transfer_length =
5601                 cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
5602         ioadl = &(ioarcb->add_data.u.ioadl[0]);
5603         ioadl->flags = IOADL_FLAGS_LAST_DESC;
5604         ioadl->address = cpu_to_le64(pinstance->timestamp_data_baddr);
5605         ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_timestamp_data));
5606 
5607         if (!pinstance->timestamp_error) {
5608                 pinstance->timestamp_error = 0;
5609                 pmcraid_send_cmd(cmd, pmcraid_set_supported_devs,
5610                          PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5611         } else {
5612                 pmcraid_send_cmd(cmd, pmcraid_return_cmd,
5613                          PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5614                 return;
5615         }
5616 }
5617 
5618 
5619 /**
5620  * pmcraid_init_res_table - Initialize the resource table
5621  * @cmd:  pointer to pmcraid command struct
5622  *
5623  * This function looks through the existing resource table, comparing
5624  * it with the config table. This function will take care of old/new
5625  * devices and schedule adding/removing them from the mid-layer
5626  * as appropriate.
5627  *
5628  * Return value
5629  *       None
5630  */
5631 static void pmcraid_init_res_table(struct pmcraid_cmd *cmd)
5632 {
5633         struct pmcraid_instance *pinstance = cmd->drv_inst;
5634         struct pmcraid_resource_entry *res, *temp;
5635         struct pmcraid_config_table_entry *cfgte;
5636         unsigned long lock_flags;
5637         int found, rc, i;
5638         u16 fw_version;
5639         LIST_HEAD(old_res);
5640 
5641         if (pinstance->cfg_table->flags & MICROCODE_UPDATE_REQUIRED)
5642                 pmcraid_err("IOA requires microcode download\n");
5643 
5644         fw_version = be16_to_cpu(pinstance->inq_data->fw_version);
5645 
5646         /* resource list is protected by pinstance->resource_lock.
5647          * init_res_table can be called from probe (user-thread) or runtime
5648          * reset (timer/tasklet)
5649          */
5650         spin_lock_irqsave(&pinstance->resource_lock, lock_flags);
5651 
5652         list_for_each_entry_safe(res, temp, &pinstance->used_res_q, queue)
5653                 list_move_tail(&res->queue, &old_res);
5654 
5655         for (i = 0; i < pinstance->cfg_table->num_entries; i++) {
5656                 if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5657                                                 PMCRAID_FW_VERSION_1)
5658                         cfgte = &pinstance->cfg_table->entries[i];
5659                 else
5660                         cfgte = (struct pmcraid_config_table_entry *)
5661                                         &pinstance->cfg_table->entries_ext[i];
5662 
5663                 if (!pmcraid_expose_resource(fw_version, cfgte))
5664                         continue;
5665 
5666                 found = 0;
5667 
5668                 /* If this entry was already detected and initialized */
5669                 list_for_each_entry_safe(res, temp, &old_res, queue) {
5670 
5671                         rc = memcmp(&res->cfg_entry.resource_address,
5672                                     &cfgte->resource_address,
5673                                     sizeof(cfgte->resource_address));
5674                         if (!rc) {
5675                                 list_move_tail(&res->queue,
5676                                                 &pinstance->used_res_q);
5677                                 found = 1;
5678                                 break;
5679                         }
5680                 }
5681 
5682                 /* If this is new entry, initialize it and add it the queue */
5683                 if (!found) {
5684 
5685                         if (list_empty(&pinstance->free_res_q)) {
5686                                 pmcraid_err("Too many devices attached\n");
5687                                 break;
5688                         }
5689 
5690                         found = 1;
5691                         res = list_entry(pinstance->free_res_q.next,
5692                                          struct pmcraid_resource_entry, queue);
5693 
5694                         res->scsi_dev = NULL;
5695                         res->change_detected = RES_CHANGE_ADD;
5696                         res->reset_progress = 0;
5697                         list_move_tail(&res->queue, &pinstance->used_res_q);
5698                 }
5699 
5700                 /* copy new configuration table entry details into driver
5701                  * maintained resource entry
5702                  */
5703                 if (found) {
5704                         memcpy(&res->cfg_entry, cfgte,
5705                                         pinstance->config_table_entry_size);
5706                         pmcraid_info("New res type:%x, vset:%x, addr:%x:\n",
5707                                  res->cfg_entry.resource_type,
5708                                  (fw_version <= PMCRAID_FW_VERSION_1 ?
5709                                         res->cfg_entry.unique_flags1 :
5710                                                 res->cfg_entry.array_id & 0xFF),
5711                                  le32_to_cpu(res->cfg_entry.resource_address));
5712                 }
5713         }
5714 
5715         /* Detect any deleted entries, mark them for deletion from mid-layer */
5716         list_for_each_entry_safe(res, temp, &old_res, queue) {
5717 
5718                 if (res->scsi_dev) {
5719                         res->change_detected = RES_CHANGE_DEL;
5720                         res->cfg_entry.resource_handle =
5721                                 PMCRAID_INVALID_RES_HANDLE;
5722                         list_move_tail(&res->queue, &pinstance->used_res_q);
5723                 } else {
5724                         list_move_tail(&res->queue, &pinstance->free_res_q);
5725                 }
5726         }
5727 
5728         /* release the resource list lock */
5729         spin_unlock_irqrestore(&pinstance->resource_lock, lock_flags);
5730         pmcraid_set_timestamp(cmd);
5731 }
5732 
5733 /**
5734  * pmcraid_querycfg - Send a Query IOA Config to the adapter.
5735  * @cmd: pointer pmcraid_cmd struct
5736  *
5737  * This function sends a Query IOA Configuration command to the adapter to
5738  * retrieve the IOA configuration table.
5739  *
5740  * Return value:
5741  *      none
5742  */
5743 static void pmcraid_querycfg(struct pmcraid_cmd *cmd)
5744 {
5745         struct pmcraid_ioarcb *ioarcb = &cmd->ioa_cb->ioarcb;
5746         struct pmcraid_ioadl_desc *ioadl = ioarcb->add_data.u.ioadl;
5747         struct pmcraid_instance *pinstance = cmd->drv_inst;
5748         int cfg_table_size = cpu_to_be32(sizeof(struct pmcraid_config_table));
5749 
5750         if (be16_to_cpu(pinstance->inq_data->fw_version) <=
5751                                         PMCRAID_FW_VERSION_1)
5752                 pinstance->config_table_entry_size =
5753                         sizeof(struct pmcraid_config_table_entry);
5754         else
5755                 pinstance->config_table_entry_size =
5756                         sizeof(struct pmcraid_config_table_entry_ext);
5757 
5758         ioarcb->request_type = REQ_TYPE_IOACMD;
5759         ioarcb->resource_handle = cpu_to_le32(PMCRAID_IOA_RES_HANDLE);
5760 
5761         ioarcb->cdb[0] = PMCRAID_QUERY_IOA_CONFIG;
5762 
5763         /* firmware requires 4-byte length field, specified in B.E format */
5764         memcpy(&(ioarcb->cdb[10]), &cfg_table_size, sizeof(cfg_table_size));
5765 
5766         /* Since entire config table can be described by single IOADL, it can
5767          * be part of IOARCB itself
5768          */
5769         ioarcb->ioadl_bus_addr = cpu_to_le64((cmd->ioa_cb_bus_addr) +
5770                                         offsetof(struct pmcraid_ioarcb,
5771                                                 add_data.u.ioadl[0]));
5772         ioarcb->ioadl_length = cpu_to_le32(sizeof(struct pmcraid_ioadl_desc));
5773         ioarcb->ioarcb_bus_addr &= ~(0x1FULL);
5774 
5775         ioarcb->request_flags0 |= NO_LINK_DESCS;
5776         ioarcb->data_transfer_length =
5777                 cpu_to_le32(sizeof(struct pmcraid_config_table));
5778 
5779         ioadl = &(ioarcb->add_data.u.ioadl[0]);
5780         ioadl->flags = IOADL_FLAGS_LAST_DESC;
5781         ioadl->address = cpu_to_le64(pinstance->cfg_table_bus_addr);
5782         ioadl->data_len = cpu_to_le32(sizeof(struct pmcraid_config_table));
5783 
5784         pmcraid_send_cmd(cmd, pmcraid_init_res_table,
5785                          PMCRAID_INTERNAL_TIMEOUT, pmcraid_timeout_handler);
5786 }
5787 
5788 
5789 /**
5790  * pmcraid_probe - PCI probe entry pointer for PMC MaxRAID controller driver
5791  * @pdev: pointer to pci device structure
5792  * @dev_id: pointer to device ids structure
5793  *
5794  * Return Value
5795  *      returns 0 if the device is claimed and successfully configured.
5796  *      returns non-zero error code in case of any failure
5797  */
5798 static int pmcraid_probe(struct pci_dev *pdev,
5799                          const struct pci_device_id *dev_id)
5800 {
5801         struct pmcraid_instance *pinstance;
5802         struct Scsi_Host *host;
5803         void __iomem *mapped_pci_addr;
5804         int rc = PCIBIOS_SUCCESSFUL;
5805 
5806         if (atomic_read(&pmcraid_adapter_count) >= PMCRAID_MAX_ADAPTERS) {
5807                 pmcraid_err
5808                         ("maximum number(%d) of supported adapters reached\n",
5809                          atomic_read(&pmcraid_adapter_count));
5810                 return -ENOMEM;
5811         }
5812 
5813         atomic_inc(&pmcraid_adapter_count);
5814         rc = pci_enable_device(pdev);
5815 
5816         if (rc) {
5817                 dev_err(&pdev->dev, "Cannot enable adapter\n");
5818                 atomic_dec(&pmcraid_adapter_count);
5819                 return rc;
5820         }
5821 
5822         dev_info(&pdev->dev,
5823                 "Found new IOA(%x:%x), Total IOA count: %d\n",
5824                  pdev->vendor, pdev->device,
5825                  atomic_read(&pmcraid_adapter_count));
5826 
5827         rc = pci_request_regions(pdev, PMCRAID_DRIVER_NAME);
5828 
5829         if (rc < 0) {
5830                 dev_err(&pdev->dev,
5831                         "Couldn't register memory range of registers\n");
5832                 goto out_disable_device;
5833         }
5834 
5835         mapped_pci_addr = pci_iomap(pdev, 0, 0);
5836 
5837         if (!mapped_pci_addr) {
5838                 dev_err(&pdev->dev, "Couldn't map PCI registers memory\n");
5839                 rc = -ENOMEM;
5840                 goto out_release_regions;
5841         }
5842 
5843         pci_set_master(pdev);
5844 
5845         /* Firmware requires the system bus address of IOARCB to be within
5846          * 32-bit addressable range though it has 64-bit IOARRIN register.
5847          * However, firmware supports 64-bit streaming DMA buffers, whereas
5848          * coherent buffers are to be 32-bit. Since pci_alloc_consistent always
5849          * returns memory within 4GB (if not, change this logic), coherent
5850          * buffers are within firmware acceptable address ranges.
5851          */
5852         if ((sizeof(dma_addr_t) == 4) ||
5853             pci_set_dma_mask(pdev, DMA_BIT_MASK(64)))
5854                 rc = pci_set_dma_mask(pdev, DMA_BIT_MASK(32));
5855 
5856         /* firmware expects 32-bit DMA addresses for IOARRIN register; set 32
5857          * bit mask for pci_alloc_consistent to return addresses within 4GB
5858          */
5859         if (rc == 0)
5860                 rc = pci_set_consistent_dma_mask(pdev, DMA_BIT_MASK(32));
5861 
5862         if (rc != 0) {
5863                 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
5864                 goto cleanup_nomem;
5865         }
5866 
5867         host = scsi_host_alloc(&pmcraid_host_template,
5868                                 sizeof(struct pmcraid_instance));
5869 
5870         if (!host) {
5871                 dev_err(&pdev->dev, "scsi_host_alloc failed!\n");
5872                 rc = -ENOMEM;
5873                 goto cleanup_nomem;
5874         }
5875 
5876         host->max_id = PMCRAID_MAX_NUM_TARGETS_PER_BUS;
5877         host->max_lun = PMCRAID_MAX_NUM_LUNS_PER_TARGET;
5878         host->unique_id = host->host_no;
5879         host->max_channel = PMCRAID_MAX_BUS_TO_SCAN;
5880         host->max_cmd_len = PMCRAID_MAX_CDB_LEN;
5881 
5882         /* zero out entire instance structure */
5883         pinstance = (struct pmcraid_instance *)host->hostdata;
5884         memset(pinstance, 0, sizeof(*pinstance));
5885 
5886         pinstance->chip_cfg =
5887                 (struct pmcraid_chip_details *)(dev_id->driver_data);
5888 
5889         rc = pmcraid_init_instance(pdev, host, mapped_pci_addr);
5890 
5891         if (rc < 0) {
5892                 dev_err(&pdev->dev, "failed to initialize adapter instance\n");
5893                 goto out_scsi_host_put;
5894         }
5895 
5896         pci_set_drvdata(pdev, pinstance);
5897 
5898         /* Save PCI config-space for use following the reset */
5899         rc = pci_save_state(pinstance->pdev);
5900 
5901         if (rc != 0) {
5902                 dev_err(&pdev->dev, "Failed to save PCI config space\n");
5903                 goto out_scsi_host_put;
5904         }
5905 
5906         pmcraid_disable_interrupts(pinstance, ~0);
5907 
5908         rc = pmcraid_register_interrupt_handler(pinstance);
5909 
5910         if (rc) {
5911                 dev_err(&pdev->dev, "couldn't register interrupt handler\n");
5912                 goto out_scsi_host_put;
5913         }
5914 
5915         pmcraid_init_tasklets(pinstance);
5916 
5917         /* allocate verious buffers used by LLD.*/
5918         rc = pmcraid_init_buffers(pinstance);
5919 
5920         if (rc) {
5921                 pmcraid_err("couldn't allocate memory blocks\n");
5922                 goto out_unregister_isr;
5923         }
5924 
5925         /* check the reset type required */
5926         pmcraid_reset_type(pinstance);
5927 
5928         pmcraid_enable_interrupts(pinstance, PMCRAID_PCI_INTERRUPTS);
5929 
5930         /* Start IOA firmware initialization and bring card to Operational
5931          * state.
5932          */
5933         pmcraid_info("starting IOA initialization sequence\n");
5934         if (pmcraid_reset_bringup(pinstance)) {
5935                 dev_err(&pdev->dev, "couldn't initialize IOA\n");
5936                 rc = 1;
5937                 goto out_release_bufs;
5938         }
5939 
5940         /* Add adapter instance into mid-layer list */
5941         rc = scsi_add_host(pinstance->host, &pdev->dev);
5942         if (rc != 0) {
5943                 pmcraid_err("couldn't add host into mid-layer: %d\n", rc);
5944                 goto out_release_bufs;
5945         }
5946 
5947         scsi_scan_host(pinstance->host);
5948 
5949         rc = pmcraid_setup_chrdev(pinstance);
5950 
5951         if (rc != 0) {
5952                 pmcraid_err("couldn't create mgmt interface, error: %x\n",
5953                              rc);
5954                 goto out_remove_host;
5955         }
5956 
5957         /* Schedule worker thread to handle CCN and take care of adding and
5958          * removing devices to OS
5959          */
5960         atomic_set(&pinstance->expose_resources, 1);
5961         schedule_work(&pinstance->worker_q);
5962         return rc;
5963 
5964 out_remove_host:
5965         scsi_remove_host(host);
5966 
5967 out_release_bufs:
5968         pmcraid_release_buffers(pinstance);
5969 
5970 out_unregister_isr:
5971         pmcraid_kill_tasklets(pinstance);
5972         pmcraid_unregister_interrupt_handler(pinstance);
5973 
5974 out_scsi_host_put:
5975         scsi_host_put(host);
5976 
5977 cleanup_nomem:
5978         iounmap(mapped_pci_addr);
5979 
5980 out_release_regions:
5981         pci_release_regions(pdev);
5982 
5983 out_disable_device:
5984         atomic_dec(&pmcraid_adapter_count);
5985         pci_disable_device(pdev);
5986         return -ENODEV;
5987 }
5988 
5989 /*
5990  * PCI driver structure of pcmraid driver
5991  */
5992 static struct pci_driver pmcraid_driver = {
5993         .name = PMCRAID_DRIVER_NAME,
5994         .id_table = pmcraid_pci_table,
5995         .probe = pmcraid_probe,
5996         .remove = pmcraid_remove,
5997         .suspend = pmcraid_suspend,
5998         .resume = pmcraid_resume,
5999         .shutdown = pmcraid_shutdown
6000 };
6001 
6002 /**
6003  * pmcraid_init - module load entry point
6004  */
6005 static int __init pmcraid_init(void)
6006 {
6007         dev_t dev;
6008         int error;
6009 
6010         pmcraid_info("%s Device Driver version: %s\n",
6011                          PMCRAID_DRIVER_NAME, PMCRAID_DRIVER_VERSION);
6012 
6013         error = alloc_chrdev_region(&dev, 0,
6014                                     PMCRAID_MAX_ADAPTERS,
6015                                     PMCRAID_DEVFILE);
6016 
6017         if (error) {
6018                 pmcraid_err("failed to get a major number for adapters\n");
6019                 goto out_init;
6020         }
6021 
6022         pmcraid_major = MAJOR(dev);
6023         pmcraid_class = class_create(THIS_MODULE, PMCRAID_DEVFILE);
6024 
6025         if (IS_ERR(pmcraid_class)) {
6026                 error = PTR_ERR(pmcraid_class);
6027                 pmcraid_err("failed to register with sysfs, error = %x\n",
6028                             error);
6029                 goto out_unreg_chrdev;
6030         }
6031 
6032         error = pmcraid_netlink_init();
6033 
6034         if (error)
6035                 goto out_unreg_chrdev;
6036 
6037         error = pci_register_driver(&pmcraid_driver);
6038 
6039         if (error == 0)
6040                 goto out_init;
6041 
6042         pmcraid_err("failed to register pmcraid driver, error = %x\n",
6043                      error);
6044         class_destroy(pmcraid_class);
6045         pmcraid_netlink_release();
6046 
6047 out_unreg_chrdev:
6048         unregister_chrdev_region(MKDEV(pmcraid_major, 0), PMCRAID_MAX_ADAPTERS);
6049 
6050 out_init:
6051         return error;
6052 }
6053 
6054 /**
6055  * pmcraid_exit - module unload entry point
6056  */
6057 static void __exit pmcraid_exit(void)
6058 {
6059         pmcraid_netlink_release();
6060         unregister_chrdev_region(MKDEV(pmcraid_major, 0),
6061                                  PMCRAID_MAX_ADAPTERS);
6062         pci_unregister_driver(&pmcraid_driver);
6063         class_destroy(pmcraid_class);
6064 }
6065 
6066 module_init(pmcraid_init);
6067 module_exit(pmcraid_exit);
6068 

This page was automatically generated by LXR 0.3.1 (source).  •  Linux is a registered trademark of Linus Torvalds  •  Contact us