Version:  2.0.40 2.2.26 2.4.37 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7 4.8

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

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