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