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