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