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