Version:  2.0.40 2.2.26 2.4.37 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 4.9 4.10

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

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