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