xref: /openbmc/linux/drivers/scsi/ipr.c (revision e481ff3f)
1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /*
3  * ipr.c -- driver for IBM Power Linux RAID adapters
4  *
5  * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
6  *
7  * Copyright (C) 2003, 2004 IBM Corporation
8  */
9 
10 /*
11  * Notes:
12  *
13  * This driver is used to control the following SCSI adapters:
14  *
15  * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
16  *
17  * IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
18  *              PCI-X Dual Channel Ultra 320 SCSI Adapter
19  *              PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
20  *              Embedded SCSI adapter on p615 and p655 systems
21  *
22  * Supported Hardware Features:
23  *	- Ultra 320 SCSI controller
24  *	- PCI-X host interface
25  *	- Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
26  *	- Non-Volatile Write Cache
27  *	- Supports attachment of non-RAID disks, tape, and optical devices
28  *	- RAID Levels 0, 5, 10
29  *	- Hot spare
30  *	- Background Parity Checking
31  *	- Background Data Scrubbing
32  *	- Ability to increase the capacity of an existing RAID 5 disk array
33  *		by adding disks
34  *
35  * Driver Features:
36  *	- Tagged command queuing
37  *	- Adapter microcode download
38  *	- PCI hot plug
39  *	- SCSI device hot plug
40  *
41  */
42 
43 #include <linux/fs.h>
44 #include <linux/init.h>
45 #include <linux/types.h>
46 #include <linux/errno.h>
47 #include <linux/kernel.h>
48 #include <linux/slab.h>
49 #include <linux/vmalloc.h>
50 #include <linux/ioport.h>
51 #include <linux/delay.h>
52 #include <linux/pci.h>
53 #include <linux/wait.h>
54 #include <linux/spinlock.h>
55 #include <linux/sched.h>
56 #include <linux/interrupt.h>
57 #include <linux/blkdev.h>
58 #include <linux/firmware.h>
59 #include <linux/module.h>
60 #include <linux/moduleparam.h>
61 #include <linux/libata.h>
62 #include <linux/hdreg.h>
63 #include <linux/reboot.h>
64 #include <linux/stringify.h>
65 #include <asm/io.h>
66 #include <asm/irq.h>
67 #include <asm/processor.h>
68 #include <scsi/scsi.h>
69 #include <scsi/scsi_host.h>
70 #include <scsi/scsi_tcq.h>
71 #include <scsi/scsi_eh.h>
72 #include <scsi/scsi_cmnd.h>
73 #include "ipr.h"
74 
75 /*
76  *   Global Data
77  */
78 static LIST_HEAD(ipr_ioa_head);
79 static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
80 static unsigned int ipr_max_speed = 1;
81 static int ipr_testmode = 0;
82 static unsigned int ipr_fastfail = 0;
83 static unsigned int ipr_transop_timeout = 0;
84 static unsigned int ipr_debug = 0;
85 static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
86 static unsigned int ipr_dual_ioa_raid = 1;
87 static unsigned int ipr_number_of_msix = 16;
88 static unsigned int ipr_fast_reboot;
89 static DEFINE_SPINLOCK(ipr_driver_lock);
90 
91 /* This table describes the differences between DMA controller chips */
92 static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
93 	{ /* Gemstone, Citrine, Obsidian, and Obsidian-E */
94 		.mailbox = 0x0042C,
95 		.max_cmds = 100,
96 		.cache_line_size = 0x20,
97 		.clear_isr = 1,
98 		.iopoll_weight = 0,
99 		{
100 			.set_interrupt_mask_reg = 0x0022C,
101 			.clr_interrupt_mask_reg = 0x00230,
102 			.clr_interrupt_mask_reg32 = 0x00230,
103 			.sense_interrupt_mask_reg = 0x0022C,
104 			.sense_interrupt_mask_reg32 = 0x0022C,
105 			.clr_interrupt_reg = 0x00228,
106 			.clr_interrupt_reg32 = 0x00228,
107 			.sense_interrupt_reg = 0x00224,
108 			.sense_interrupt_reg32 = 0x00224,
109 			.ioarrin_reg = 0x00404,
110 			.sense_uproc_interrupt_reg = 0x00214,
111 			.sense_uproc_interrupt_reg32 = 0x00214,
112 			.set_uproc_interrupt_reg = 0x00214,
113 			.set_uproc_interrupt_reg32 = 0x00214,
114 			.clr_uproc_interrupt_reg = 0x00218,
115 			.clr_uproc_interrupt_reg32 = 0x00218
116 		}
117 	},
118 	{ /* Snipe and Scamp */
119 		.mailbox = 0x0052C,
120 		.max_cmds = 100,
121 		.cache_line_size = 0x20,
122 		.clear_isr = 1,
123 		.iopoll_weight = 0,
124 		{
125 			.set_interrupt_mask_reg = 0x00288,
126 			.clr_interrupt_mask_reg = 0x0028C,
127 			.clr_interrupt_mask_reg32 = 0x0028C,
128 			.sense_interrupt_mask_reg = 0x00288,
129 			.sense_interrupt_mask_reg32 = 0x00288,
130 			.clr_interrupt_reg = 0x00284,
131 			.clr_interrupt_reg32 = 0x00284,
132 			.sense_interrupt_reg = 0x00280,
133 			.sense_interrupt_reg32 = 0x00280,
134 			.ioarrin_reg = 0x00504,
135 			.sense_uproc_interrupt_reg = 0x00290,
136 			.sense_uproc_interrupt_reg32 = 0x00290,
137 			.set_uproc_interrupt_reg = 0x00290,
138 			.set_uproc_interrupt_reg32 = 0x00290,
139 			.clr_uproc_interrupt_reg = 0x00294,
140 			.clr_uproc_interrupt_reg32 = 0x00294
141 		}
142 	},
143 	{ /* CRoC */
144 		.mailbox = 0x00044,
145 		.max_cmds = 1000,
146 		.cache_line_size = 0x20,
147 		.clear_isr = 0,
148 		.iopoll_weight = 64,
149 		{
150 			.set_interrupt_mask_reg = 0x00010,
151 			.clr_interrupt_mask_reg = 0x00018,
152 			.clr_interrupt_mask_reg32 = 0x0001C,
153 			.sense_interrupt_mask_reg = 0x00010,
154 			.sense_interrupt_mask_reg32 = 0x00014,
155 			.clr_interrupt_reg = 0x00008,
156 			.clr_interrupt_reg32 = 0x0000C,
157 			.sense_interrupt_reg = 0x00000,
158 			.sense_interrupt_reg32 = 0x00004,
159 			.ioarrin_reg = 0x00070,
160 			.sense_uproc_interrupt_reg = 0x00020,
161 			.sense_uproc_interrupt_reg32 = 0x00024,
162 			.set_uproc_interrupt_reg = 0x00020,
163 			.set_uproc_interrupt_reg32 = 0x00024,
164 			.clr_uproc_interrupt_reg = 0x00028,
165 			.clr_uproc_interrupt_reg32 = 0x0002C,
166 			.init_feedback_reg = 0x0005C,
167 			.dump_addr_reg = 0x00064,
168 			.dump_data_reg = 0x00068,
169 			.endian_swap_reg = 0x00084
170 		}
171 	},
172 };
173 
174 static const struct ipr_chip_t ipr_chip[] = {
175 	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
176 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
177 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
178 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
179 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, true, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
180 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
181 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
182 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
183 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
184 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
185 };
186 
187 static int ipr_max_bus_speeds[] = {
188 	IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
189 };
190 
191 MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
192 MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
193 module_param_named(max_speed, ipr_max_speed, uint, 0);
194 MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
195 module_param_named(log_level, ipr_log_level, uint, 0);
196 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
197 module_param_named(testmode, ipr_testmode, int, 0);
198 MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
199 module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
200 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
201 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
202 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
203 module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
204 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
205 module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
206 MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
207 module_param_named(max_devs, ipr_max_devs, int, 0);
208 MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
209 		 "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
210 module_param_named(number_of_msix, ipr_number_of_msix, int, 0);
211 MODULE_PARM_DESC(number_of_msix, "Specify the number of MSIX interrupts to use on capable adapters (1 - 16).  (default:16)");
212 module_param_named(fast_reboot, ipr_fast_reboot, int, S_IRUGO | S_IWUSR);
213 MODULE_PARM_DESC(fast_reboot, "Skip adapter shutdown during reboot. Set to 1 to enable. (default: 0)");
214 MODULE_LICENSE("GPL");
215 MODULE_VERSION(IPR_DRIVER_VERSION);
216 
217 /*  A constant array of IOASCs/URCs/Error Messages */
218 static const
219 struct ipr_error_table_t ipr_error_table[] = {
220 	{0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
221 	"8155: An unknown error was received"},
222 	{0x00330000, 0, 0,
223 	"Soft underlength error"},
224 	{0x005A0000, 0, 0,
225 	"Command to be cancelled not found"},
226 	{0x00808000, 0, 0,
227 	"Qualified success"},
228 	{0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
229 	"FFFE: Soft device bus error recovered by the IOA"},
230 	{0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
231 	"4101: Soft device bus fabric error"},
232 	{0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
233 	"FFFC: Logical block guard error recovered by the device"},
234 	{0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
235 	"FFFC: Logical block reference tag error recovered by the device"},
236 	{0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
237 	"4171: Recovered scatter list tag / sequence number error"},
238 	{0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
239 	"FF3D: Recovered logical block CRC error on IOA to Host transfer"},
240 	{0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
241 	"4171: Recovered logical block sequence number error on IOA to Host transfer"},
242 	{0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
243 	"FFFD: Recovered logical block reference tag error detected by the IOA"},
244 	{0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
245 	"FFFD: Logical block guard error recovered by the IOA"},
246 	{0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
247 	"FFF9: Device sector reassign successful"},
248 	{0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
249 	"FFF7: Media error recovered by device rewrite procedures"},
250 	{0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
251 	"7001: IOA sector reassignment successful"},
252 	{0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
253 	"FFF9: Soft media error. Sector reassignment recommended"},
254 	{0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
255 	"FFF7: Media error recovered by IOA rewrite procedures"},
256 	{0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
257 	"FF3D: Soft PCI bus error recovered by the IOA"},
258 	{0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
259 	"FFF6: Device hardware error recovered by the IOA"},
260 	{0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
261 	"FFF6: Device hardware error recovered by the device"},
262 	{0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
263 	"FF3D: Soft IOA error recovered by the IOA"},
264 	{0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
265 	"FFFA: Undefined device response recovered by the IOA"},
266 	{0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
267 	"FFF6: Device bus error, message or command phase"},
268 	{0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
269 	"FFFE: Task Management Function failed"},
270 	{0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
271 	"FFF6: Failure prediction threshold exceeded"},
272 	{0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
273 	"8009: Impending cache battery pack failure"},
274 	{0x02040100, 0, 0,
275 	"Logical Unit in process of becoming ready"},
276 	{0x02040200, 0, 0,
277 	"Initializing command required"},
278 	{0x02040400, 0, 0,
279 	"34FF: Disk device format in progress"},
280 	{0x02040C00, 0, 0,
281 	"Logical unit not accessible, target port in unavailable state"},
282 	{0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
283 	"9070: IOA requested reset"},
284 	{0x023F0000, 0, 0,
285 	"Synchronization required"},
286 	{0x02408500, 0, 0,
287 	"IOA microcode download required"},
288 	{0x02408600, 0, 0,
289 	"Device bus connection is prohibited by host"},
290 	{0x024E0000, 0, 0,
291 	"No ready, IOA shutdown"},
292 	{0x025A0000, 0, 0,
293 	"Not ready, IOA has been shutdown"},
294 	{0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
295 	"3020: Storage subsystem configuration error"},
296 	{0x03110B00, 0, 0,
297 	"FFF5: Medium error, data unreadable, recommend reassign"},
298 	{0x03110C00, 0, 0,
299 	"7000: Medium error, data unreadable, do not reassign"},
300 	{0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
301 	"FFF3: Disk media format bad"},
302 	{0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
303 	"3002: Addressed device failed to respond to selection"},
304 	{0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
305 	"3100: Device bus error"},
306 	{0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
307 	"3109: IOA timed out a device command"},
308 	{0x04088000, 0, 0,
309 	"3120: SCSI bus is not operational"},
310 	{0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
311 	"4100: Hard device bus fabric error"},
312 	{0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
313 	"310C: Logical block guard error detected by the device"},
314 	{0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
315 	"310C: Logical block reference tag error detected by the device"},
316 	{0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
317 	"4170: Scatter list tag / sequence number error"},
318 	{0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
319 	"8150: Logical block CRC error on IOA to Host transfer"},
320 	{0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
321 	"4170: Logical block sequence number error on IOA to Host transfer"},
322 	{0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
323 	"310D: Logical block reference tag error detected by the IOA"},
324 	{0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
325 	"310D: Logical block guard error detected by the IOA"},
326 	{0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
327 	"9000: IOA reserved area data check"},
328 	{0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
329 	"9001: IOA reserved area invalid data pattern"},
330 	{0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
331 	"9002: IOA reserved area LRC error"},
332 	{0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
333 	"Hardware Error, IOA metadata access error"},
334 	{0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
335 	"102E: Out of alternate sectors for disk storage"},
336 	{0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
337 	"FFF4: Data transfer underlength error"},
338 	{0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
339 	"FFF4: Data transfer overlength error"},
340 	{0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
341 	"3400: Logical unit failure"},
342 	{0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
343 	"FFF4: Device microcode is corrupt"},
344 	{0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
345 	"8150: PCI bus error"},
346 	{0x04430000, 1, 0,
347 	"Unsupported device bus message received"},
348 	{0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
349 	"FFF4: Disk device problem"},
350 	{0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
351 	"8150: Permanent IOA failure"},
352 	{0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
353 	"3010: Disk device returned wrong response to IOA"},
354 	{0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
355 	"8151: IOA microcode error"},
356 	{0x04448500, 0, 0,
357 	"Device bus status error"},
358 	{0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
359 	"8157: IOA error requiring IOA reset to recover"},
360 	{0x04448700, 0, 0,
361 	"ATA device status error"},
362 	{0x04490000, 0, 0,
363 	"Message reject received from the device"},
364 	{0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
365 	"8008: A permanent cache battery pack failure occurred"},
366 	{0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
367 	"9090: Disk unit has been modified after the last known status"},
368 	{0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
369 	"9081: IOA detected device error"},
370 	{0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
371 	"9082: IOA detected device error"},
372 	{0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
373 	"3110: Device bus error, message or command phase"},
374 	{0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
375 	"3110: SAS Command / Task Management Function failed"},
376 	{0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
377 	"9091: Incorrect hardware configuration change has been detected"},
378 	{0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
379 	"9073: Invalid multi-adapter configuration"},
380 	{0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
381 	"4010: Incorrect connection between cascaded expanders"},
382 	{0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
383 	"4020: Connections exceed IOA design limits"},
384 	{0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
385 	"4030: Incorrect multipath connection"},
386 	{0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
387 	"4110: Unsupported enclosure function"},
388 	{0x04679800, 0, IPR_DEFAULT_LOG_LEVEL,
389 	"4120: SAS cable VPD cannot be read"},
390 	{0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
391 	"FFF4: Command to logical unit failed"},
392 	{0x05240000, 1, 0,
393 	"Illegal request, invalid request type or request packet"},
394 	{0x05250000, 0, 0,
395 	"Illegal request, invalid resource handle"},
396 	{0x05258000, 0, 0,
397 	"Illegal request, commands not allowed to this device"},
398 	{0x05258100, 0, 0,
399 	"Illegal request, command not allowed to a secondary adapter"},
400 	{0x05258200, 0, 0,
401 	"Illegal request, command not allowed to a non-optimized resource"},
402 	{0x05260000, 0, 0,
403 	"Illegal request, invalid field in parameter list"},
404 	{0x05260100, 0, 0,
405 	"Illegal request, parameter not supported"},
406 	{0x05260200, 0, 0,
407 	"Illegal request, parameter value invalid"},
408 	{0x052C0000, 0, 0,
409 	"Illegal request, command sequence error"},
410 	{0x052C8000, 1, 0,
411 	"Illegal request, dual adapter support not enabled"},
412 	{0x052C8100, 1, 0,
413 	"Illegal request, another cable connector was physically disabled"},
414 	{0x054E8000, 1, 0,
415 	"Illegal request, inconsistent group id/group count"},
416 	{0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
417 	"9031: Array protection temporarily suspended, protection resuming"},
418 	{0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
419 	"9040: Array protection temporarily suspended, protection resuming"},
420 	{0x060B0100, 0, IPR_DEFAULT_LOG_LEVEL,
421 	"4080: IOA exceeded maximum operating temperature"},
422 	{0x060B8000, 0, IPR_DEFAULT_LOG_LEVEL,
423 	"4085: Service required"},
424 	{0x060B8100, 0, IPR_DEFAULT_LOG_LEVEL,
425 	"4086: SAS Adapter Hardware Configuration Error"},
426 	{0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
427 	"3140: Device bus not ready to ready transition"},
428 	{0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
429 	"FFFB: SCSI bus was reset"},
430 	{0x06290500, 0, 0,
431 	"FFFE: SCSI bus transition to single ended"},
432 	{0x06290600, 0, 0,
433 	"FFFE: SCSI bus transition to LVD"},
434 	{0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
435 	"FFFB: SCSI bus was reset by another initiator"},
436 	{0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
437 	"3029: A device replacement has occurred"},
438 	{0x063F8300, 0, IPR_DEFAULT_LOG_LEVEL,
439 	"4102: Device bus fabric performance degradation"},
440 	{0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
441 	"9051: IOA cache data exists for a missing or failed device"},
442 	{0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
443 	"9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
444 	{0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
445 	"9025: Disk unit is not supported at its physical location"},
446 	{0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
447 	"3020: IOA detected a SCSI bus configuration error"},
448 	{0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
449 	"3150: SCSI bus configuration error"},
450 	{0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
451 	"9074: Asymmetric advanced function disk configuration"},
452 	{0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
453 	"4040: Incomplete multipath connection between IOA and enclosure"},
454 	{0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
455 	"4041: Incomplete multipath connection between enclosure and device"},
456 	{0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
457 	"9075: Incomplete multipath connection between IOA and remote IOA"},
458 	{0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
459 	"9076: Configuration error, missing remote IOA"},
460 	{0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
461 	"4050: Enclosure does not support a required multipath function"},
462 	{0x06679800, 0, IPR_DEFAULT_LOG_LEVEL,
463 	"4121: Configuration error, required cable is missing"},
464 	{0x06679900, 0, IPR_DEFAULT_LOG_LEVEL,
465 	"4122: Cable is not plugged into the correct location on remote IOA"},
466 	{0x06679A00, 0, IPR_DEFAULT_LOG_LEVEL,
467 	"4123: Configuration error, invalid cable vital product data"},
468 	{0x06679B00, 0, IPR_DEFAULT_LOG_LEVEL,
469 	"4124: Configuration error, both cable ends are plugged into the same IOA"},
470 	{0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
471 	"4070: Logically bad block written on device"},
472 	{0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
473 	"9041: Array protection temporarily suspended"},
474 	{0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
475 	"9042: Corrupt array parity detected on specified device"},
476 	{0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
477 	"9030: Array no longer protected due to missing or failed disk unit"},
478 	{0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
479 	"9071: Link operational transition"},
480 	{0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
481 	"9072: Link not operational transition"},
482 	{0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
483 	"9032: Array exposed but still protected"},
484 	{0x066B8300, 0, IPR_DEBUG_LOG_LEVEL,
485 	"70DD: Device forced failed by disrupt device command"},
486 	{0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
487 	"4061: Multipath redundancy level got better"},
488 	{0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
489 	"4060: Multipath redundancy level got worse"},
490 	{0x06808100, 0, IPR_DEBUG_LOG_LEVEL,
491 	"9083: Device raw mode enabled"},
492 	{0x06808200, 0, IPR_DEBUG_LOG_LEVEL,
493 	"9084: Device raw mode disabled"},
494 	{0x07270000, 0, 0,
495 	"Failure due to other device"},
496 	{0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
497 	"9008: IOA does not support functions expected by devices"},
498 	{0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
499 	"9010: Cache data associated with attached devices cannot be found"},
500 	{0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
501 	"9011: Cache data belongs to devices other than those attached"},
502 	{0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
503 	"9020: Array missing 2 or more devices with only 1 device present"},
504 	{0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
505 	"9021: Array missing 2 or more devices with 2 or more devices present"},
506 	{0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
507 	"9022: Exposed array is missing a required device"},
508 	{0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
509 	"9023: Array member(s) not at required physical locations"},
510 	{0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
511 	"9024: Array not functional due to present hardware configuration"},
512 	{0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
513 	"9026: Array not functional due to present hardware configuration"},
514 	{0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
515 	"9027: Array is missing a device and parity is out of sync"},
516 	{0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
517 	"9028: Maximum number of arrays already exist"},
518 	{0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
519 	"9050: Required cache data cannot be located for a disk unit"},
520 	{0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
521 	"9052: Cache data exists for a device that has been modified"},
522 	{0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
523 	"9054: IOA resources not available due to previous problems"},
524 	{0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
525 	"9092: Disk unit requires initialization before use"},
526 	{0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
527 	"9029: Incorrect hardware configuration change has been detected"},
528 	{0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
529 	"9060: One or more disk pairs are missing from an array"},
530 	{0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
531 	"9061: One or more disks are missing from an array"},
532 	{0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
533 	"9062: One or more disks are missing from an array"},
534 	{0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
535 	"9063: Maximum number of functional arrays has been exceeded"},
536 	{0x07279A00, 0, 0,
537 	"Data protect, other volume set problem"},
538 	{0x0B260000, 0, 0,
539 	"Aborted command, invalid descriptor"},
540 	{0x0B3F9000, 0, 0,
541 	"Target operating conditions have changed, dual adapter takeover"},
542 	{0x0B530200, 0, 0,
543 	"Aborted command, medium removal prevented"},
544 	{0x0B5A0000, 0, 0,
545 	"Command terminated by host"},
546 	{0x0B5B8000, 0, 0,
547 	"Aborted command, command terminated by host"}
548 };
549 
550 static const struct ipr_ses_table_entry ipr_ses_table[] = {
551 	{ "2104-DL1        ", "XXXXXXXXXXXXXXXX", 80 },
552 	{ "2104-TL1        ", "XXXXXXXXXXXXXXXX", 80 },
553 	{ "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
554 	{ "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
555 	{ "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
556 	{ "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
557 	{ "2104-DU3        ", "XXXXXXXXXXXXXXXX", 160 },
558 	{ "2104-TU3        ", "XXXXXXXXXXXXXXXX", 160 },
559 	{ "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
560 	{ "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
561 	{ "St  V1S2        ", "XXXXXXXXXXXXXXXX", 160 },
562 	{ "HSBPD4M  PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
563 	{ "VSBPD1H   U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
564 };
565 
566 /*
567  *  Function Prototypes
568  */
569 static int ipr_reset_alert(struct ipr_cmnd *);
570 static void ipr_process_ccn(struct ipr_cmnd *);
571 static void ipr_process_error(struct ipr_cmnd *);
572 static void ipr_reset_ioa_job(struct ipr_cmnd *);
573 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
574 				   enum ipr_shutdown_type);
575 
576 #ifdef CONFIG_SCSI_IPR_TRACE
577 /**
578  * ipr_trc_hook - Add a trace entry to the driver trace
579  * @ipr_cmd:	ipr command struct
580  * @type:		trace type
581  * @add_data:	additional data
582  *
583  * Return value:
584  * 	none
585  **/
586 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
587 			 u8 type, u32 add_data)
588 {
589 	struct ipr_trace_entry *trace_entry;
590 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
591 	unsigned int trace_index;
592 
593 	trace_index = atomic_add_return(1, &ioa_cfg->trace_index) & IPR_TRACE_INDEX_MASK;
594 	trace_entry = &ioa_cfg->trace[trace_index];
595 	trace_entry->time = jiffies;
596 	trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
597 	trace_entry->type = type;
598 	if (ipr_cmd->ioa_cfg->sis64)
599 		trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
600 	else
601 		trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
602 	trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
603 	trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
604 	trace_entry->u.add_data = add_data;
605 	wmb();
606 }
607 #else
608 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
609 #endif
610 
611 /**
612  * ipr_lock_and_done - Acquire lock and complete command
613  * @ipr_cmd:	ipr command struct
614  *
615  * Return value:
616  *	none
617  **/
618 static void ipr_lock_and_done(struct ipr_cmnd *ipr_cmd)
619 {
620 	unsigned long lock_flags;
621 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
622 
623 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
624 	ipr_cmd->done(ipr_cmd);
625 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
626 }
627 
628 /**
629  * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
630  * @ipr_cmd:	ipr command struct
631  *
632  * Return value:
633  * 	none
634  **/
635 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
636 {
637 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
638 	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
639 	struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
640 	dma_addr_t dma_addr = ipr_cmd->dma_addr;
641 	int hrrq_id;
642 
643 	hrrq_id = ioarcb->cmd_pkt.hrrq_id;
644 	memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
645 	ioarcb->cmd_pkt.hrrq_id = hrrq_id;
646 	ioarcb->data_transfer_length = 0;
647 	ioarcb->read_data_transfer_length = 0;
648 	ioarcb->ioadl_len = 0;
649 	ioarcb->read_ioadl_len = 0;
650 
651 	if (ipr_cmd->ioa_cfg->sis64) {
652 		ioarcb->u.sis64_addr_data.data_ioadl_addr =
653 			cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
654 		ioasa64->u.gata.status = 0;
655 	} else {
656 		ioarcb->write_ioadl_addr =
657 			cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
658 		ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
659 		ioasa->u.gata.status = 0;
660 	}
661 
662 	ioasa->hdr.ioasc = 0;
663 	ioasa->hdr.residual_data_len = 0;
664 	ipr_cmd->scsi_cmd = NULL;
665 	ipr_cmd->qc = NULL;
666 	ipr_cmd->sense_buffer[0] = 0;
667 	ipr_cmd->dma_use_sg = 0;
668 }
669 
670 /**
671  * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
672  * @ipr_cmd:	ipr command struct
673  * @fast_done:	fast done function call-back
674  *
675  * Return value:
676  * 	none
677  **/
678 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd,
679 			      void (*fast_done) (struct ipr_cmnd *))
680 {
681 	ipr_reinit_ipr_cmnd(ipr_cmd);
682 	ipr_cmd->u.scratch = 0;
683 	ipr_cmd->sibling = NULL;
684 	ipr_cmd->eh_comp = NULL;
685 	ipr_cmd->fast_done = fast_done;
686 	timer_setup(&ipr_cmd->timer, NULL, 0);
687 }
688 
689 /**
690  * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
691  * @hrrq:	hrr queue
692  *
693  * Return value:
694  * 	pointer to ipr command struct
695  **/
696 static
697 struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq)
698 {
699 	struct ipr_cmnd *ipr_cmd = NULL;
700 
701 	if (likely(!list_empty(&hrrq->hrrq_free_q))) {
702 		ipr_cmd = list_entry(hrrq->hrrq_free_q.next,
703 			struct ipr_cmnd, queue);
704 		list_del(&ipr_cmd->queue);
705 	}
706 
707 
708 	return ipr_cmd;
709 }
710 
711 /**
712  * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
713  * @ioa_cfg:	ioa config struct
714  *
715  * Return value:
716  *	pointer to ipr command struct
717  **/
718 static
719 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
720 {
721 	struct ipr_cmnd *ipr_cmd =
722 		__ipr_get_free_ipr_cmnd(&ioa_cfg->hrrq[IPR_INIT_HRRQ]);
723 	ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
724 	return ipr_cmd;
725 }
726 
727 /**
728  * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
729  * @ioa_cfg:	ioa config struct
730  * @clr_ints:     interrupts to clear
731  *
732  * This function masks all interrupts on the adapter, then clears the
733  * interrupts specified in the mask
734  *
735  * Return value:
736  * 	none
737  **/
738 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
739 					  u32 clr_ints)
740 {
741 	int i;
742 
743 	/* Stop new interrupts */
744 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
745 		spin_lock(&ioa_cfg->hrrq[i]._lock);
746 		ioa_cfg->hrrq[i].allow_interrupts = 0;
747 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
748 	}
749 
750 	/* Set interrupt mask to stop all new interrupts */
751 	if (ioa_cfg->sis64)
752 		writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
753 	else
754 		writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
755 
756 	/* Clear any pending interrupts */
757 	if (ioa_cfg->sis64)
758 		writel(~0, ioa_cfg->regs.clr_interrupt_reg);
759 	writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
760 	readl(ioa_cfg->regs.sense_interrupt_reg);
761 }
762 
763 /**
764  * ipr_save_pcix_cmd_reg - Save PCI-X command register
765  * @ioa_cfg:	ioa config struct
766  *
767  * Return value:
768  * 	0 on success / -EIO on failure
769  **/
770 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
771 {
772 	int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
773 
774 	if (pcix_cmd_reg == 0)
775 		return 0;
776 
777 	if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
778 				 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
779 		dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
780 		return -EIO;
781 	}
782 
783 	ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
784 	return 0;
785 }
786 
787 /**
788  * ipr_set_pcix_cmd_reg - Setup PCI-X command register
789  * @ioa_cfg:	ioa config struct
790  *
791  * Return value:
792  * 	0 on success / -EIO on failure
793  **/
794 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
795 {
796 	int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
797 
798 	if (pcix_cmd_reg) {
799 		if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
800 					  ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
801 			dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
802 			return -EIO;
803 		}
804 	}
805 
806 	return 0;
807 }
808 
809 /**
810  * __ipr_sata_eh_done - done function for aborted SATA commands
811  * @ipr_cmd:	ipr command struct
812  *
813  * This function is invoked for ops generated to SATA
814  * devices which are being aborted.
815  *
816  * Return value:
817  * 	none
818  **/
819 static void __ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
820 {
821 	struct ata_queued_cmd *qc = ipr_cmd->qc;
822 	struct ipr_sata_port *sata_port = qc->ap->private_data;
823 
824 	qc->err_mask |= AC_ERR_OTHER;
825 	sata_port->ioasa.status |= ATA_BUSY;
826 	ata_qc_complete(qc);
827 	if (ipr_cmd->eh_comp)
828 		complete(ipr_cmd->eh_comp);
829 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
830 }
831 
832 /**
833  * ipr_sata_eh_done - done function for aborted SATA commands
834  * @ipr_cmd:	ipr command struct
835  *
836  * This function is invoked for ops generated to SATA
837  * devices which are being aborted.
838  *
839  * Return value:
840  * 	none
841  **/
842 static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
843 {
844 	struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
845 	unsigned long hrrq_flags;
846 
847 	spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
848 	__ipr_sata_eh_done(ipr_cmd);
849 	spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
850 }
851 
852 /**
853  * __ipr_scsi_eh_done - mid-layer done function for aborted ops
854  * @ipr_cmd:	ipr command struct
855  *
856  * This function is invoked by the interrupt handler for
857  * ops generated by the SCSI mid-layer which are being aborted.
858  *
859  * Return value:
860  * 	none
861  **/
862 static void __ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
863 {
864 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
865 
866 	scsi_cmd->result |= (DID_ERROR << 16);
867 
868 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
869 	scsi_cmd->scsi_done(scsi_cmd);
870 	if (ipr_cmd->eh_comp)
871 		complete(ipr_cmd->eh_comp);
872 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
873 }
874 
875 /**
876  * ipr_scsi_eh_done - mid-layer done function for aborted ops
877  * @ipr_cmd:	ipr command struct
878  *
879  * This function is invoked by the interrupt handler for
880  * ops generated by the SCSI mid-layer which are being aborted.
881  *
882  * Return value:
883  * 	none
884  **/
885 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
886 {
887 	unsigned long hrrq_flags;
888 	struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
889 
890 	spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
891 	__ipr_scsi_eh_done(ipr_cmd);
892 	spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
893 }
894 
895 /**
896  * ipr_fail_all_ops - Fails all outstanding ops.
897  * @ioa_cfg:	ioa config struct
898  *
899  * This function fails all outstanding ops.
900  *
901  * Return value:
902  * 	none
903  **/
904 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
905 {
906 	struct ipr_cmnd *ipr_cmd, *temp;
907 	struct ipr_hrr_queue *hrrq;
908 
909 	ENTER;
910 	for_each_hrrq(hrrq, ioa_cfg) {
911 		spin_lock(&hrrq->_lock);
912 		list_for_each_entry_safe(ipr_cmd,
913 					temp, &hrrq->hrrq_pending_q, queue) {
914 			list_del(&ipr_cmd->queue);
915 
916 			ipr_cmd->s.ioasa.hdr.ioasc =
917 				cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
918 			ipr_cmd->s.ioasa.hdr.ilid =
919 				cpu_to_be32(IPR_DRIVER_ILID);
920 
921 			if (ipr_cmd->scsi_cmd)
922 				ipr_cmd->done = __ipr_scsi_eh_done;
923 			else if (ipr_cmd->qc)
924 				ipr_cmd->done = __ipr_sata_eh_done;
925 
926 			ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH,
927 				     IPR_IOASC_IOA_WAS_RESET);
928 			del_timer(&ipr_cmd->timer);
929 			ipr_cmd->done(ipr_cmd);
930 		}
931 		spin_unlock(&hrrq->_lock);
932 	}
933 	LEAVE;
934 }
935 
936 /**
937  * ipr_send_command -  Send driver initiated requests.
938  * @ipr_cmd:		ipr command struct
939  *
940  * This function sends a command to the adapter using the correct write call.
941  * In the case of sis64, calculate the ioarcb size required. Then or in the
942  * appropriate bits.
943  *
944  * Return value:
945  * 	none
946  **/
947 static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
948 {
949 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
950 	dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
951 
952 	if (ioa_cfg->sis64) {
953 		/* The default size is 256 bytes */
954 		send_dma_addr |= 0x1;
955 
956 		/* If the number of ioadls * size of ioadl > 128 bytes,
957 		   then use a 512 byte ioarcb */
958 		if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
959 			send_dma_addr |= 0x4;
960 		writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
961 	} else
962 		writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
963 }
964 
965 /**
966  * ipr_do_req -  Send driver initiated requests.
967  * @ipr_cmd:		ipr command struct
968  * @done:			done function
969  * @timeout_func:	timeout function
970  * @timeout:		timeout value
971  *
972  * This function sends the specified command to the adapter with the
973  * timeout given. The done function is invoked on command completion.
974  *
975  * Return value:
976  * 	none
977  **/
978 static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
979 		       void (*done) (struct ipr_cmnd *),
980 		       void (*timeout_func) (struct timer_list *), u32 timeout)
981 {
982 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
983 
984 	ipr_cmd->done = done;
985 
986 	ipr_cmd->timer.expires = jiffies + timeout;
987 	ipr_cmd->timer.function = timeout_func;
988 
989 	add_timer(&ipr_cmd->timer);
990 
991 	ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
992 
993 	ipr_send_command(ipr_cmd);
994 }
995 
996 /**
997  * ipr_internal_cmd_done - Op done function for an internally generated op.
998  * @ipr_cmd:	ipr command struct
999  *
1000  * This function is the op done function for an internally generated,
1001  * blocking op. It simply wakes the sleeping thread.
1002  *
1003  * Return value:
1004  * 	none
1005  **/
1006 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
1007 {
1008 	if (ipr_cmd->sibling)
1009 		ipr_cmd->sibling = NULL;
1010 	else
1011 		complete(&ipr_cmd->completion);
1012 }
1013 
1014 /**
1015  * ipr_init_ioadl - initialize the ioadl for the correct SIS type
1016  * @ipr_cmd:	ipr command struct
1017  * @dma_addr:	dma address
1018  * @len:	transfer length
1019  * @flags:	ioadl flag value
1020  *
1021  * This function initializes an ioadl in the case where there is only a single
1022  * descriptor.
1023  *
1024  * Return value:
1025  * 	nothing
1026  **/
1027 static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
1028 			   u32 len, int flags)
1029 {
1030 	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
1031 	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
1032 
1033 	ipr_cmd->dma_use_sg = 1;
1034 
1035 	if (ipr_cmd->ioa_cfg->sis64) {
1036 		ioadl64->flags = cpu_to_be32(flags);
1037 		ioadl64->data_len = cpu_to_be32(len);
1038 		ioadl64->address = cpu_to_be64(dma_addr);
1039 
1040 		ipr_cmd->ioarcb.ioadl_len =
1041 		       	cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
1042 		ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
1043 	} else {
1044 		ioadl->flags_and_data_len = cpu_to_be32(flags | len);
1045 		ioadl->address = cpu_to_be32(dma_addr);
1046 
1047 		if (flags == IPR_IOADL_FLAGS_READ_LAST) {
1048 			ipr_cmd->ioarcb.read_ioadl_len =
1049 				cpu_to_be32(sizeof(struct ipr_ioadl_desc));
1050 			ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
1051 		} else {
1052 			ipr_cmd->ioarcb.ioadl_len =
1053 			       	cpu_to_be32(sizeof(struct ipr_ioadl_desc));
1054 			ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
1055 		}
1056 	}
1057 }
1058 
1059 /**
1060  * ipr_send_blocking_cmd - Send command and sleep on its completion.
1061  * @ipr_cmd:	ipr command struct
1062  * @timeout_func:	function to invoke if command times out
1063  * @timeout:	timeout
1064  *
1065  * Return value:
1066  * 	none
1067  **/
1068 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
1069 				  void (*timeout_func) (struct timer_list *),
1070 				  u32 timeout)
1071 {
1072 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1073 
1074 	init_completion(&ipr_cmd->completion);
1075 	ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
1076 
1077 	spin_unlock_irq(ioa_cfg->host->host_lock);
1078 	wait_for_completion(&ipr_cmd->completion);
1079 	spin_lock_irq(ioa_cfg->host->host_lock);
1080 }
1081 
1082 static int ipr_get_hrrq_index(struct ipr_ioa_cfg *ioa_cfg)
1083 {
1084 	unsigned int hrrq;
1085 
1086 	if (ioa_cfg->hrrq_num == 1)
1087 		hrrq = 0;
1088 	else {
1089 		hrrq = atomic_add_return(1, &ioa_cfg->hrrq_index);
1090 		hrrq = (hrrq % (ioa_cfg->hrrq_num - 1)) + 1;
1091 	}
1092 	return hrrq;
1093 }
1094 
1095 /**
1096  * ipr_send_hcam - Send an HCAM to the adapter.
1097  * @ioa_cfg:	ioa config struct
1098  * @type:		HCAM type
1099  * @hostrcb:	hostrcb struct
1100  *
1101  * This function will send a Host Controlled Async command to the adapter.
1102  * If HCAMs are currently not allowed to be issued to the adapter, it will
1103  * place the hostrcb on the free queue.
1104  *
1105  * Return value:
1106  * 	none
1107  **/
1108 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
1109 			  struct ipr_hostrcb *hostrcb)
1110 {
1111 	struct ipr_cmnd *ipr_cmd;
1112 	struct ipr_ioarcb *ioarcb;
1113 
1114 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
1115 		ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
1116 		list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
1117 		list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
1118 
1119 		ipr_cmd->u.hostrcb = hostrcb;
1120 		ioarcb = &ipr_cmd->ioarcb;
1121 
1122 		ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
1123 		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
1124 		ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
1125 		ioarcb->cmd_pkt.cdb[1] = type;
1126 		ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
1127 		ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
1128 
1129 		ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
1130 			       sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
1131 
1132 		if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
1133 			ipr_cmd->done = ipr_process_ccn;
1134 		else
1135 			ipr_cmd->done = ipr_process_error;
1136 
1137 		ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
1138 
1139 		ipr_send_command(ipr_cmd);
1140 	} else {
1141 		list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
1142 	}
1143 }
1144 
1145 /**
1146  * ipr_update_ata_class - Update the ata class in the resource entry
1147  * @res:	resource entry struct
1148  * @proto:	cfgte device bus protocol value
1149  *
1150  * Return value:
1151  * 	none
1152  **/
1153 static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1154 {
1155 	switch (proto) {
1156 	case IPR_PROTO_SATA:
1157 	case IPR_PROTO_SAS_STP:
1158 		res->ata_class = ATA_DEV_ATA;
1159 		break;
1160 	case IPR_PROTO_SATA_ATAPI:
1161 	case IPR_PROTO_SAS_STP_ATAPI:
1162 		res->ata_class = ATA_DEV_ATAPI;
1163 		break;
1164 	default:
1165 		res->ata_class = ATA_DEV_UNKNOWN;
1166 		break;
1167 	}
1168 }
1169 
1170 /**
1171  * ipr_init_res_entry - Initialize a resource entry struct.
1172  * @res:	resource entry struct
1173  * @cfgtew:	config table entry wrapper struct
1174  *
1175  * Return value:
1176  * 	none
1177  **/
1178 static void ipr_init_res_entry(struct ipr_resource_entry *res,
1179 			       struct ipr_config_table_entry_wrapper *cfgtew)
1180 {
1181 	int found = 0;
1182 	unsigned int proto;
1183 	struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1184 	struct ipr_resource_entry *gscsi_res = NULL;
1185 
1186 	res->needs_sync_complete = 0;
1187 	res->in_erp = 0;
1188 	res->add_to_ml = 0;
1189 	res->del_from_ml = 0;
1190 	res->resetting_device = 0;
1191 	res->reset_occurred = 0;
1192 	res->sdev = NULL;
1193 	res->sata_port = NULL;
1194 
1195 	if (ioa_cfg->sis64) {
1196 		proto = cfgtew->u.cfgte64->proto;
1197 		res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
1198 		res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
1199 		res->qmodel = IPR_QUEUEING_MODEL64(res);
1200 		res->type = cfgtew->u.cfgte64->res_type;
1201 
1202 		memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1203 			sizeof(res->res_path));
1204 
1205 		res->bus = 0;
1206 		memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1207 			sizeof(res->dev_lun.scsi_lun));
1208 		res->lun = scsilun_to_int(&res->dev_lun);
1209 
1210 		if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1211 			list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
1212 				if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
1213 					found = 1;
1214 					res->target = gscsi_res->target;
1215 					break;
1216 				}
1217 			}
1218 			if (!found) {
1219 				res->target = find_first_zero_bit(ioa_cfg->target_ids,
1220 								  ioa_cfg->max_devs_supported);
1221 				set_bit(res->target, ioa_cfg->target_ids);
1222 			}
1223 		} else if (res->type == IPR_RES_TYPE_IOAFP) {
1224 			res->bus = IPR_IOAFP_VIRTUAL_BUS;
1225 			res->target = 0;
1226 		} else if (res->type == IPR_RES_TYPE_ARRAY) {
1227 			res->bus = IPR_ARRAY_VIRTUAL_BUS;
1228 			res->target = find_first_zero_bit(ioa_cfg->array_ids,
1229 							  ioa_cfg->max_devs_supported);
1230 			set_bit(res->target, ioa_cfg->array_ids);
1231 		} else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
1232 			res->bus = IPR_VSET_VIRTUAL_BUS;
1233 			res->target = find_first_zero_bit(ioa_cfg->vset_ids,
1234 							  ioa_cfg->max_devs_supported);
1235 			set_bit(res->target, ioa_cfg->vset_ids);
1236 		} else {
1237 			res->target = find_first_zero_bit(ioa_cfg->target_ids,
1238 							  ioa_cfg->max_devs_supported);
1239 			set_bit(res->target, ioa_cfg->target_ids);
1240 		}
1241 	} else {
1242 		proto = cfgtew->u.cfgte->proto;
1243 		res->qmodel = IPR_QUEUEING_MODEL(res);
1244 		res->flags = cfgtew->u.cfgte->flags;
1245 		if (res->flags & IPR_IS_IOA_RESOURCE)
1246 			res->type = IPR_RES_TYPE_IOAFP;
1247 		else
1248 			res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1249 
1250 		res->bus = cfgtew->u.cfgte->res_addr.bus;
1251 		res->target = cfgtew->u.cfgte->res_addr.target;
1252 		res->lun = cfgtew->u.cfgte->res_addr.lun;
1253 		res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
1254 	}
1255 
1256 	ipr_update_ata_class(res, proto);
1257 }
1258 
1259 /**
1260  * ipr_is_same_device - Determine if two devices are the same.
1261  * @res:	resource entry struct
1262  * @cfgtew:	config table entry wrapper struct
1263  *
1264  * Return value:
1265  * 	1 if the devices are the same / 0 otherwise
1266  **/
1267 static int ipr_is_same_device(struct ipr_resource_entry *res,
1268 			      struct ipr_config_table_entry_wrapper *cfgtew)
1269 {
1270 	if (res->ioa_cfg->sis64) {
1271 		if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
1272 					sizeof(cfgtew->u.cfgte64->dev_id)) &&
1273 			!memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1274 					sizeof(cfgtew->u.cfgte64->lun))) {
1275 			return 1;
1276 		}
1277 	} else {
1278 		if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
1279 		    res->target == cfgtew->u.cfgte->res_addr.target &&
1280 		    res->lun == cfgtew->u.cfgte->res_addr.lun)
1281 			return 1;
1282 	}
1283 
1284 	return 0;
1285 }
1286 
1287 /**
1288  * __ipr_format_res_path - Format the resource path for printing.
1289  * @res_path:	resource path
1290  * @buffer:	buffer
1291  * @len:	length of buffer provided
1292  *
1293  * Return value:
1294  * 	pointer to buffer
1295  **/
1296 static char *__ipr_format_res_path(u8 *res_path, char *buffer, int len)
1297 {
1298 	int i;
1299 	char *p = buffer;
1300 
1301 	*p = '\0';
1302 	p += scnprintf(p, buffer + len - p, "%02X", res_path[0]);
1303 	for (i = 1; res_path[i] != 0xff && i < IPR_RES_PATH_BYTES; i++)
1304 		p += scnprintf(p, buffer + len - p, "-%02X", res_path[i]);
1305 
1306 	return buffer;
1307 }
1308 
1309 /**
1310  * ipr_format_res_path - Format the resource path for printing.
1311  * @ioa_cfg:	ioa config struct
1312  * @res_path:	resource path
1313  * @buffer:	buffer
1314  * @len:	length of buffer provided
1315  *
1316  * Return value:
1317  *	pointer to buffer
1318  **/
1319 static char *ipr_format_res_path(struct ipr_ioa_cfg *ioa_cfg,
1320 				 u8 *res_path, char *buffer, int len)
1321 {
1322 	char *p = buffer;
1323 
1324 	*p = '\0';
1325 	p += scnprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no);
1326 	__ipr_format_res_path(res_path, p, len - (p - buffer));
1327 	return buffer;
1328 }
1329 
1330 /**
1331  * ipr_update_res_entry - Update the resource entry.
1332  * @res:	resource entry struct
1333  * @cfgtew:	config table entry wrapper struct
1334  *
1335  * Return value:
1336  *      none
1337  **/
1338 static void ipr_update_res_entry(struct ipr_resource_entry *res,
1339 				 struct ipr_config_table_entry_wrapper *cfgtew)
1340 {
1341 	char buffer[IPR_MAX_RES_PATH_LENGTH];
1342 	unsigned int proto;
1343 	int new_path = 0;
1344 
1345 	if (res->ioa_cfg->sis64) {
1346 		res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
1347 		res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
1348 		res->type = cfgtew->u.cfgte64->res_type;
1349 
1350 		memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1351 			sizeof(struct ipr_std_inq_data));
1352 
1353 		res->qmodel = IPR_QUEUEING_MODEL64(res);
1354 		proto = cfgtew->u.cfgte64->proto;
1355 		res->res_handle = cfgtew->u.cfgte64->res_handle;
1356 		res->dev_id = cfgtew->u.cfgte64->dev_id;
1357 
1358 		memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1359 			sizeof(res->dev_lun.scsi_lun));
1360 
1361 		if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
1362 					sizeof(res->res_path))) {
1363 			memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1364 				sizeof(res->res_path));
1365 			new_path = 1;
1366 		}
1367 
1368 		if (res->sdev && new_path)
1369 			sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
1370 				    ipr_format_res_path(res->ioa_cfg,
1371 					res->res_path, buffer, sizeof(buffer)));
1372 	} else {
1373 		res->flags = cfgtew->u.cfgte->flags;
1374 		if (res->flags & IPR_IS_IOA_RESOURCE)
1375 			res->type = IPR_RES_TYPE_IOAFP;
1376 		else
1377 			res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1378 
1379 		memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1380 			sizeof(struct ipr_std_inq_data));
1381 
1382 		res->qmodel = IPR_QUEUEING_MODEL(res);
1383 		proto = cfgtew->u.cfgte->proto;
1384 		res->res_handle = cfgtew->u.cfgte->res_handle;
1385 	}
1386 
1387 	ipr_update_ata_class(res, proto);
1388 }
1389 
1390 /**
1391  * ipr_clear_res_target - Clear the bit in the bit map representing the target
1392  * 			  for the resource.
1393  * @res:	resource entry struct
1394  *
1395  * Return value:
1396  *      none
1397  **/
1398 static void ipr_clear_res_target(struct ipr_resource_entry *res)
1399 {
1400 	struct ipr_resource_entry *gscsi_res = NULL;
1401 	struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1402 
1403 	if (!ioa_cfg->sis64)
1404 		return;
1405 
1406 	if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
1407 		clear_bit(res->target, ioa_cfg->array_ids);
1408 	else if (res->bus == IPR_VSET_VIRTUAL_BUS)
1409 		clear_bit(res->target, ioa_cfg->vset_ids);
1410 	else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1411 		list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
1412 			if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
1413 				return;
1414 		clear_bit(res->target, ioa_cfg->target_ids);
1415 
1416 	} else if (res->bus == 0)
1417 		clear_bit(res->target, ioa_cfg->target_ids);
1418 }
1419 
1420 /**
1421  * ipr_handle_config_change - Handle a config change from the adapter
1422  * @ioa_cfg:	ioa config struct
1423  * @hostrcb:	hostrcb
1424  *
1425  * Return value:
1426  * 	none
1427  **/
1428 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1429 				     struct ipr_hostrcb *hostrcb)
1430 {
1431 	struct ipr_resource_entry *res = NULL;
1432 	struct ipr_config_table_entry_wrapper cfgtew;
1433 	__be32 cc_res_handle;
1434 
1435 	u32 is_ndn = 1;
1436 
1437 	if (ioa_cfg->sis64) {
1438 		cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1439 		cc_res_handle = cfgtew.u.cfgte64->res_handle;
1440 	} else {
1441 		cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1442 		cc_res_handle = cfgtew.u.cfgte->res_handle;
1443 	}
1444 
1445 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1446 		if (res->res_handle == cc_res_handle) {
1447 			is_ndn = 0;
1448 			break;
1449 		}
1450 	}
1451 
1452 	if (is_ndn) {
1453 		if (list_empty(&ioa_cfg->free_res_q)) {
1454 			ipr_send_hcam(ioa_cfg,
1455 				      IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1456 				      hostrcb);
1457 			return;
1458 		}
1459 
1460 		res = list_entry(ioa_cfg->free_res_q.next,
1461 				 struct ipr_resource_entry, queue);
1462 
1463 		list_del(&res->queue);
1464 		ipr_init_res_entry(res, &cfgtew);
1465 		list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1466 	}
1467 
1468 	ipr_update_res_entry(res, &cfgtew);
1469 
1470 	if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1471 		if (res->sdev) {
1472 			res->del_from_ml = 1;
1473 			res->res_handle = IPR_INVALID_RES_HANDLE;
1474 			schedule_work(&ioa_cfg->work_q);
1475 		} else {
1476 			ipr_clear_res_target(res);
1477 			list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1478 		}
1479 	} else if (!res->sdev || res->del_from_ml) {
1480 		res->add_to_ml = 1;
1481 		schedule_work(&ioa_cfg->work_q);
1482 	}
1483 
1484 	ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1485 }
1486 
1487 /**
1488  * ipr_process_ccn - Op done function for a CCN.
1489  * @ipr_cmd:	ipr command struct
1490  *
1491  * This function is the op done function for a configuration
1492  * change notification host controlled async from the adapter.
1493  *
1494  * Return value:
1495  * 	none
1496  **/
1497 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
1498 {
1499 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1500 	struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1501 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
1502 
1503 	list_del_init(&hostrcb->queue);
1504 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
1505 
1506 	if (ioasc) {
1507 		if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
1508 		    ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST)
1509 			dev_err(&ioa_cfg->pdev->dev,
1510 				"Host RCB failed with IOASC: 0x%08X\n", ioasc);
1511 
1512 		ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1513 	} else {
1514 		ipr_handle_config_change(ioa_cfg, hostrcb);
1515 	}
1516 }
1517 
1518 /**
1519  * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1520  * @i:		index into buffer
1521  * @buf:		string to modify
1522  *
1523  * This function will strip all trailing whitespace, pad the end
1524  * of the string with a single space, and NULL terminate the string.
1525  *
1526  * Return value:
1527  * 	new length of string
1528  **/
1529 static int strip_and_pad_whitespace(int i, char *buf)
1530 {
1531 	while (i && buf[i] == ' ')
1532 		i--;
1533 	buf[i+1] = ' ';
1534 	buf[i+2] = '\0';
1535 	return i + 2;
1536 }
1537 
1538 /**
1539  * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1540  * @prefix:		string to print at start of printk
1541  * @hostrcb:	hostrcb pointer
1542  * @vpd:		vendor/product id/sn struct
1543  *
1544  * Return value:
1545  * 	none
1546  **/
1547 static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1548 				struct ipr_vpd *vpd)
1549 {
1550 	char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
1551 	int i = 0;
1552 
1553 	memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1554 	i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
1555 
1556 	memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
1557 	i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
1558 
1559 	memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
1560 	buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
1561 
1562 	ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
1563 }
1564 
1565 /**
1566  * ipr_log_vpd - Log the passed VPD to the error log.
1567  * @vpd:		vendor/product id/sn struct
1568  *
1569  * Return value:
1570  * 	none
1571  **/
1572 static void ipr_log_vpd(struct ipr_vpd *vpd)
1573 {
1574 	char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1575 		    + IPR_SERIAL_NUM_LEN];
1576 
1577 	memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1578 	memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1579 	       IPR_PROD_ID_LEN);
1580 	buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1581 	ipr_err("Vendor/Product ID: %s\n", buffer);
1582 
1583 	memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1584 	buffer[IPR_SERIAL_NUM_LEN] = '\0';
1585 	ipr_err("    Serial Number: %s\n", buffer);
1586 }
1587 
1588 /**
1589  * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1590  * @prefix:		string to print at start of printk
1591  * @hostrcb:	hostrcb pointer
1592  * @vpd:		vendor/product id/sn/wwn struct
1593  *
1594  * Return value:
1595  * 	none
1596  **/
1597 static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1598 				    struct ipr_ext_vpd *vpd)
1599 {
1600 	ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1601 	ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1602 		     be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1603 }
1604 
1605 /**
1606  * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1607  * @vpd:		vendor/product id/sn/wwn struct
1608  *
1609  * Return value:
1610  * 	none
1611  **/
1612 static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1613 {
1614 	ipr_log_vpd(&vpd->vpd);
1615 	ipr_err("    WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1616 		be32_to_cpu(vpd->wwid[1]));
1617 }
1618 
1619 /**
1620  * ipr_log_enhanced_cache_error - Log a cache error.
1621  * @ioa_cfg:	ioa config struct
1622  * @hostrcb:	hostrcb struct
1623  *
1624  * Return value:
1625  * 	none
1626  **/
1627 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1628 					 struct ipr_hostrcb *hostrcb)
1629 {
1630 	struct ipr_hostrcb_type_12_error *error;
1631 
1632 	if (ioa_cfg->sis64)
1633 		error = &hostrcb->hcam.u.error64.u.type_12_error;
1634 	else
1635 		error = &hostrcb->hcam.u.error.u.type_12_error;
1636 
1637 	ipr_err("-----Current Configuration-----\n");
1638 	ipr_err("Cache Directory Card Information:\n");
1639 	ipr_log_ext_vpd(&error->ioa_vpd);
1640 	ipr_err("Adapter Card Information:\n");
1641 	ipr_log_ext_vpd(&error->cfc_vpd);
1642 
1643 	ipr_err("-----Expected Configuration-----\n");
1644 	ipr_err("Cache Directory Card Information:\n");
1645 	ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1646 	ipr_err("Adapter Card Information:\n");
1647 	ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1648 
1649 	ipr_err("Additional IOA Data: %08X %08X %08X\n",
1650 		     be32_to_cpu(error->ioa_data[0]),
1651 		     be32_to_cpu(error->ioa_data[1]),
1652 		     be32_to_cpu(error->ioa_data[2]));
1653 }
1654 
1655 /**
1656  * ipr_log_cache_error - Log a cache error.
1657  * @ioa_cfg:	ioa config struct
1658  * @hostrcb:	hostrcb struct
1659  *
1660  * Return value:
1661  * 	none
1662  **/
1663 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1664 				struct ipr_hostrcb *hostrcb)
1665 {
1666 	struct ipr_hostrcb_type_02_error *error =
1667 		&hostrcb->hcam.u.error.u.type_02_error;
1668 
1669 	ipr_err("-----Current Configuration-----\n");
1670 	ipr_err("Cache Directory Card Information:\n");
1671 	ipr_log_vpd(&error->ioa_vpd);
1672 	ipr_err("Adapter Card Information:\n");
1673 	ipr_log_vpd(&error->cfc_vpd);
1674 
1675 	ipr_err("-----Expected Configuration-----\n");
1676 	ipr_err("Cache Directory Card Information:\n");
1677 	ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1678 	ipr_err("Adapter Card Information:\n");
1679 	ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1680 
1681 	ipr_err("Additional IOA Data: %08X %08X %08X\n",
1682 		     be32_to_cpu(error->ioa_data[0]),
1683 		     be32_to_cpu(error->ioa_data[1]),
1684 		     be32_to_cpu(error->ioa_data[2]));
1685 }
1686 
1687 /**
1688  * ipr_log_enhanced_config_error - Log a configuration error.
1689  * @ioa_cfg:	ioa config struct
1690  * @hostrcb:	hostrcb struct
1691  *
1692  * Return value:
1693  * 	none
1694  **/
1695 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1696 					  struct ipr_hostrcb *hostrcb)
1697 {
1698 	int errors_logged, i;
1699 	struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1700 	struct ipr_hostrcb_type_13_error *error;
1701 
1702 	error = &hostrcb->hcam.u.error.u.type_13_error;
1703 	errors_logged = be32_to_cpu(error->errors_logged);
1704 
1705 	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1706 		be32_to_cpu(error->errors_detected), errors_logged);
1707 
1708 	dev_entry = error->dev;
1709 
1710 	for (i = 0; i < errors_logged; i++, dev_entry++) {
1711 		ipr_err_separator;
1712 
1713 		ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1714 		ipr_log_ext_vpd(&dev_entry->vpd);
1715 
1716 		ipr_err("-----New Device Information-----\n");
1717 		ipr_log_ext_vpd(&dev_entry->new_vpd);
1718 
1719 		ipr_err("Cache Directory Card Information:\n");
1720 		ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1721 
1722 		ipr_err("Adapter Card Information:\n");
1723 		ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1724 	}
1725 }
1726 
1727 /**
1728  * ipr_log_sis64_config_error - Log a device error.
1729  * @ioa_cfg:	ioa config struct
1730  * @hostrcb:	hostrcb struct
1731  *
1732  * Return value:
1733  * 	none
1734  **/
1735 static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1736 				       struct ipr_hostrcb *hostrcb)
1737 {
1738 	int errors_logged, i;
1739 	struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1740 	struct ipr_hostrcb_type_23_error *error;
1741 	char buffer[IPR_MAX_RES_PATH_LENGTH];
1742 
1743 	error = &hostrcb->hcam.u.error64.u.type_23_error;
1744 	errors_logged = be32_to_cpu(error->errors_logged);
1745 
1746 	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1747 		be32_to_cpu(error->errors_detected), errors_logged);
1748 
1749 	dev_entry = error->dev;
1750 
1751 	for (i = 0; i < errors_logged; i++, dev_entry++) {
1752 		ipr_err_separator;
1753 
1754 		ipr_err("Device %d : %s", i + 1,
1755 			__ipr_format_res_path(dev_entry->res_path,
1756 					      buffer, sizeof(buffer)));
1757 		ipr_log_ext_vpd(&dev_entry->vpd);
1758 
1759 		ipr_err("-----New Device Information-----\n");
1760 		ipr_log_ext_vpd(&dev_entry->new_vpd);
1761 
1762 		ipr_err("Cache Directory Card Information:\n");
1763 		ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1764 
1765 		ipr_err("Adapter Card Information:\n");
1766 		ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1767 	}
1768 }
1769 
1770 /**
1771  * ipr_log_config_error - Log a configuration error.
1772  * @ioa_cfg:	ioa config struct
1773  * @hostrcb:	hostrcb struct
1774  *
1775  * Return value:
1776  * 	none
1777  **/
1778 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1779 				 struct ipr_hostrcb *hostrcb)
1780 {
1781 	int errors_logged, i;
1782 	struct ipr_hostrcb_device_data_entry *dev_entry;
1783 	struct ipr_hostrcb_type_03_error *error;
1784 
1785 	error = &hostrcb->hcam.u.error.u.type_03_error;
1786 	errors_logged = be32_to_cpu(error->errors_logged);
1787 
1788 	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1789 		be32_to_cpu(error->errors_detected), errors_logged);
1790 
1791 	dev_entry = error->dev;
1792 
1793 	for (i = 0; i < errors_logged; i++, dev_entry++) {
1794 		ipr_err_separator;
1795 
1796 		ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1797 		ipr_log_vpd(&dev_entry->vpd);
1798 
1799 		ipr_err("-----New Device Information-----\n");
1800 		ipr_log_vpd(&dev_entry->new_vpd);
1801 
1802 		ipr_err("Cache Directory Card Information:\n");
1803 		ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1804 
1805 		ipr_err("Adapter Card Information:\n");
1806 		ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1807 
1808 		ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1809 			be32_to_cpu(dev_entry->ioa_data[0]),
1810 			be32_to_cpu(dev_entry->ioa_data[1]),
1811 			be32_to_cpu(dev_entry->ioa_data[2]),
1812 			be32_to_cpu(dev_entry->ioa_data[3]),
1813 			be32_to_cpu(dev_entry->ioa_data[4]));
1814 	}
1815 }
1816 
1817 /**
1818  * ipr_log_enhanced_array_error - Log an array configuration error.
1819  * @ioa_cfg:	ioa config struct
1820  * @hostrcb:	hostrcb struct
1821  *
1822  * Return value:
1823  * 	none
1824  **/
1825 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1826 					 struct ipr_hostrcb *hostrcb)
1827 {
1828 	int i, num_entries;
1829 	struct ipr_hostrcb_type_14_error *error;
1830 	struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1831 	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1832 
1833 	error = &hostrcb->hcam.u.error.u.type_14_error;
1834 
1835 	ipr_err_separator;
1836 
1837 	ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1838 		error->protection_level,
1839 		ioa_cfg->host->host_no,
1840 		error->last_func_vset_res_addr.bus,
1841 		error->last_func_vset_res_addr.target,
1842 		error->last_func_vset_res_addr.lun);
1843 
1844 	ipr_err_separator;
1845 
1846 	array_entry = error->array_member;
1847 	num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1848 			    ARRAY_SIZE(error->array_member));
1849 
1850 	for (i = 0; i < num_entries; i++, array_entry++) {
1851 		if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1852 			continue;
1853 
1854 		if (be32_to_cpu(error->exposed_mode_adn) == i)
1855 			ipr_err("Exposed Array Member %d:\n", i);
1856 		else
1857 			ipr_err("Array Member %d:\n", i);
1858 
1859 		ipr_log_ext_vpd(&array_entry->vpd);
1860 		ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1861 		ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1862 				 "Expected Location");
1863 
1864 		ipr_err_separator;
1865 	}
1866 }
1867 
1868 /**
1869  * ipr_log_array_error - Log an array configuration error.
1870  * @ioa_cfg:	ioa config struct
1871  * @hostrcb:	hostrcb struct
1872  *
1873  * Return value:
1874  * 	none
1875  **/
1876 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1877 				struct ipr_hostrcb *hostrcb)
1878 {
1879 	int i;
1880 	struct ipr_hostrcb_type_04_error *error;
1881 	struct ipr_hostrcb_array_data_entry *array_entry;
1882 	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1883 
1884 	error = &hostrcb->hcam.u.error.u.type_04_error;
1885 
1886 	ipr_err_separator;
1887 
1888 	ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1889 		error->protection_level,
1890 		ioa_cfg->host->host_no,
1891 		error->last_func_vset_res_addr.bus,
1892 		error->last_func_vset_res_addr.target,
1893 		error->last_func_vset_res_addr.lun);
1894 
1895 	ipr_err_separator;
1896 
1897 	array_entry = error->array_member;
1898 
1899 	for (i = 0; i < 18; i++) {
1900 		if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1901 			continue;
1902 
1903 		if (be32_to_cpu(error->exposed_mode_adn) == i)
1904 			ipr_err("Exposed Array Member %d:\n", i);
1905 		else
1906 			ipr_err("Array Member %d:\n", i);
1907 
1908 		ipr_log_vpd(&array_entry->vpd);
1909 
1910 		ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1911 		ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1912 				 "Expected Location");
1913 
1914 		ipr_err_separator;
1915 
1916 		if (i == 9)
1917 			array_entry = error->array_member2;
1918 		else
1919 			array_entry++;
1920 	}
1921 }
1922 
1923 /**
1924  * ipr_log_hex_data - Log additional hex IOA error data.
1925  * @ioa_cfg:	ioa config struct
1926  * @data:		IOA error data
1927  * @len:		data length
1928  *
1929  * Return value:
1930  * 	none
1931  **/
1932 static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, __be32 *data, int len)
1933 {
1934 	int i;
1935 
1936 	if (len == 0)
1937 		return;
1938 
1939 	if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1940 		len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1941 
1942 	for (i = 0; i < len / 4; i += 4) {
1943 		ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1944 			be32_to_cpu(data[i]),
1945 			be32_to_cpu(data[i+1]),
1946 			be32_to_cpu(data[i+2]),
1947 			be32_to_cpu(data[i+3]));
1948 	}
1949 }
1950 
1951 /**
1952  * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1953  * @ioa_cfg:	ioa config struct
1954  * @hostrcb:	hostrcb struct
1955  *
1956  * Return value:
1957  * 	none
1958  **/
1959 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1960 					    struct ipr_hostrcb *hostrcb)
1961 {
1962 	struct ipr_hostrcb_type_17_error *error;
1963 
1964 	if (ioa_cfg->sis64)
1965 		error = &hostrcb->hcam.u.error64.u.type_17_error;
1966 	else
1967 		error = &hostrcb->hcam.u.error.u.type_17_error;
1968 
1969 	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1970 	strim(error->failure_reason);
1971 
1972 	ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1973 		     be32_to_cpu(hostrcb->hcam.u.error.prc));
1974 	ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1975 	ipr_log_hex_data(ioa_cfg, error->data,
1976 			 be32_to_cpu(hostrcb->hcam.length) -
1977 			 (offsetof(struct ipr_hostrcb_error, u) +
1978 			  offsetof(struct ipr_hostrcb_type_17_error, data)));
1979 }
1980 
1981 /**
1982  * ipr_log_dual_ioa_error - Log a dual adapter error.
1983  * @ioa_cfg:	ioa config struct
1984  * @hostrcb:	hostrcb struct
1985  *
1986  * Return value:
1987  * 	none
1988  **/
1989 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1990 				   struct ipr_hostrcb *hostrcb)
1991 {
1992 	struct ipr_hostrcb_type_07_error *error;
1993 
1994 	error = &hostrcb->hcam.u.error.u.type_07_error;
1995 	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1996 	strim(error->failure_reason);
1997 
1998 	ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1999 		     be32_to_cpu(hostrcb->hcam.u.error.prc));
2000 	ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
2001 	ipr_log_hex_data(ioa_cfg, error->data,
2002 			 be32_to_cpu(hostrcb->hcam.length) -
2003 			 (offsetof(struct ipr_hostrcb_error, u) +
2004 			  offsetof(struct ipr_hostrcb_type_07_error, data)));
2005 }
2006 
2007 static const struct {
2008 	u8 active;
2009 	char *desc;
2010 } path_active_desc[] = {
2011 	{ IPR_PATH_NO_INFO, "Path" },
2012 	{ IPR_PATH_ACTIVE, "Active path" },
2013 	{ IPR_PATH_NOT_ACTIVE, "Inactive path" }
2014 };
2015 
2016 static const struct {
2017 	u8 state;
2018 	char *desc;
2019 } path_state_desc[] = {
2020 	{ IPR_PATH_STATE_NO_INFO, "has no path state information available" },
2021 	{ IPR_PATH_HEALTHY, "is healthy" },
2022 	{ IPR_PATH_DEGRADED, "is degraded" },
2023 	{ IPR_PATH_FAILED, "is failed" }
2024 };
2025 
2026 /**
2027  * ipr_log_fabric_path - Log a fabric path error
2028  * @hostrcb:	hostrcb struct
2029  * @fabric:		fabric descriptor
2030  *
2031  * Return value:
2032  * 	none
2033  **/
2034 static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
2035 				struct ipr_hostrcb_fabric_desc *fabric)
2036 {
2037 	int i, j;
2038 	u8 path_state = fabric->path_state;
2039 	u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2040 	u8 state = path_state & IPR_PATH_STATE_MASK;
2041 
2042 	for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2043 		if (path_active_desc[i].active != active)
2044 			continue;
2045 
2046 		for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2047 			if (path_state_desc[j].state != state)
2048 				continue;
2049 
2050 			if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
2051 				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
2052 					     path_active_desc[i].desc, path_state_desc[j].desc,
2053 					     fabric->ioa_port);
2054 			} else if (fabric->cascaded_expander == 0xff) {
2055 				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
2056 					     path_active_desc[i].desc, path_state_desc[j].desc,
2057 					     fabric->ioa_port, fabric->phy);
2058 			} else if (fabric->phy == 0xff) {
2059 				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
2060 					     path_active_desc[i].desc, path_state_desc[j].desc,
2061 					     fabric->ioa_port, fabric->cascaded_expander);
2062 			} else {
2063 				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
2064 					     path_active_desc[i].desc, path_state_desc[j].desc,
2065 					     fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2066 			}
2067 			return;
2068 		}
2069 	}
2070 
2071 	ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
2072 		fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2073 }
2074 
2075 /**
2076  * ipr_log64_fabric_path - Log a fabric path error
2077  * @hostrcb:	hostrcb struct
2078  * @fabric:		fabric descriptor
2079  *
2080  * Return value:
2081  * 	none
2082  **/
2083 static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
2084 				  struct ipr_hostrcb64_fabric_desc *fabric)
2085 {
2086 	int i, j;
2087 	u8 path_state = fabric->path_state;
2088 	u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2089 	u8 state = path_state & IPR_PATH_STATE_MASK;
2090 	char buffer[IPR_MAX_RES_PATH_LENGTH];
2091 
2092 	for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2093 		if (path_active_desc[i].active != active)
2094 			continue;
2095 
2096 		for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2097 			if (path_state_desc[j].state != state)
2098 				continue;
2099 
2100 			ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
2101 				     path_active_desc[i].desc, path_state_desc[j].desc,
2102 				     ipr_format_res_path(hostrcb->ioa_cfg,
2103 						fabric->res_path,
2104 						buffer, sizeof(buffer)));
2105 			return;
2106 		}
2107 	}
2108 
2109 	ipr_err("Path state=%02X Resource Path=%s\n", path_state,
2110 		ipr_format_res_path(hostrcb->ioa_cfg, fabric->res_path,
2111 				    buffer, sizeof(buffer)));
2112 }
2113 
2114 static const struct {
2115 	u8 type;
2116 	char *desc;
2117 } path_type_desc[] = {
2118 	{ IPR_PATH_CFG_IOA_PORT, "IOA port" },
2119 	{ IPR_PATH_CFG_EXP_PORT, "Expander port" },
2120 	{ IPR_PATH_CFG_DEVICE_PORT, "Device port" },
2121 	{ IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
2122 };
2123 
2124 static const struct {
2125 	u8 status;
2126 	char *desc;
2127 } path_status_desc[] = {
2128 	{ IPR_PATH_CFG_NO_PROB, "Functional" },
2129 	{ IPR_PATH_CFG_DEGRADED, "Degraded" },
2130 	{ IPR_PATH_CFG_FAILED, "Failed" },
2131 	{ IPR_PATH_CFG_SUSPECT, "Suspect" },
2132 	{ IPR_PATH_NOT_DETECTED, "Missing" },
2133 	{ IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
2134 };
2135 
2136 static const char *link_rate[] = {
2137 	"unknown",
2138 	"disabled",
2139 	"phy reset problem",
2140 	"spinup hold",
2141 	"port selector",
2142 	"unknown",
2143 	"unknown",
2144 	"unknown",
2145 	"1.5Gbps",
2146 	"3.0Gbps",
2147 	"unknown",
2148 	"unknown",
2149 	"unknown",
2150 	"unknown",
2151 	"unknown",
2152 	"unknown"
2153 };
2154 
2155 /**
2156  * ipr_log_path_elem - Log a fabric path element.
2157  * @hostrcb:	hostrcb struct
2158  * @cfg:		fabric path element struct
2159  *
2160  * Return value:
2161  * 	none
2162  **/
2163 static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
2164 			      struct ipr_hostrcb_config_element *cfg)
2165 {
2166 	int i, j;
2167 	u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2168 	u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2169 
2170 	if (type == IPR_PATH_CFG_NOT_EXIST)
2171 		return;
2172 
2173 	for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2174 		if (path_type_desc[i].type != type)
2175 			continue;
2176 
2177 		for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2178 			if (path_status_desc[j].status != status)
2179 				continue;
2180 
2181 			if (type == IPR_PATH_CFG_IOA_PORT) {
2182 				ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2183 					     path_status_desc[j].desc, path_type_desc[i].desc,
2184 					     cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2185 					     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2186 			} else {
2187 				if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2188 					ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2189 						     path_status_desc[j].desc, path_type_desc[i].desc,
2190 						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2191 						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2192 				} else if (cfg->cascaded_expander == 0xff) {
2193 					ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2194 						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2195 						     path_type_desc[i].desc, cfg->phy,
2196 						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2197 						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2198 				} else if (cfg->phy == 0xff) {
2199 					ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2200 						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2201 						     path_type_desc[i].desc, cfg->cascaded_expander,
2202 						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2203 						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2204 				} else {
2205 					ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2206 						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2207 						     path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2208 						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2209 						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2210 				}
2211 			}
2212 			return;
2213 		}
2214 	}
2215 
2216 	ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2217 		     "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2218 		     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2219 		     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2220 }
2221 
2222 /**
2223  * ipr_log64_path_elem - Log a fabric path element.
2224  * @hostrcb:	hostrcb struct
2225  * @cfg:		fabric path element struct
2226  *
2227  * Return value:
2228  * 	none
2229  **/
2230 static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2231 				struct ipr_hostrcb64_config_element *cfg)
2232 {
2233 	int i, j;
2234 	u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2235 	u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2236 	u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2237 	char buffer[IPR_MAX_RES_PATH_LENGTH];
2238 
2239 	if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2240 		return;
2241 
2242 	for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2243 		if (path_type_desc[i].type != type)
2244 			continue;
2245 
2246 		for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2247 			if (path_status_desc[j].status != status)
2248 				continue;
2249 
2250 			ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2251 				     path_status_desc[j].desc, path_type_desc[i].desc,
2252 				     ipr_format_res_path(hostrcb->ioa_cfg,
2253 					cfg->res_path, buffer, sizeof(buffer)),
2254 					link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2255 					be32_to_cpu(cfg->wwid[0]),
2256 					be32_to_cpu(cfg->wwid[1]));
2257 			return;
2258 		}
2259 	}
2260 	ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2261 		     "WWN=%08X%08X\n", cfg->type_status,
2262 		     ipr_format_res_path(hostrcb->ioa_cfg,
2263 			cfg->res_path, buffer, sizeof(buffer)),
2264 			link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2265 			be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2266 }
2267 
2268 /**
2269  * ipr_log_fabric_error - Log a fabric error.
2270  * @ioa_cfg:	ioa config struct
2271  * @hostrcb:	hostrcb struct
2272  *
2273  * Return value:
2274  * 	none
2275  **/
2276 static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2277 				 struct ipr_hostrcb *hostrcb)
2278 {
2279 	struct ipr_hostrcb_type_20_error *error;
2280 	struct ipr_hostrcb_fabric_desc *fabric;
2281 	struct ipr_hostrcb_config_element *cfg;
2282 	int i, add_len;
2283 
2284 	error = &hostrcb->hcam.u.error.u.type_20_error;
2285 	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2286 	ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2287 
2288 	add_len = be32_to_cpu(hostrcb->hcam.length) -
2289 		(offsetof(struct ipr_hostrcb_error, u) +
2290 		 offsetof(struct ipr_hostrcb_type_20_error, desc));
2291 
2292 	for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2293 		ipr_log_fabric_path(hostrcb, fabric);
2294 		for_each_fabric_cfg(fabric, cfg)
2295 			ipr_log_path_elem(hostrcb, cfg);
2296 
2297 		add_len -= be16_to_cpu(fabric->length);
2298 		fabric = (struct ipr_hostrcb_fabric_desc *)
2299 			((unsigned long)fabric + be16_to_cpu(fabric->length));
2300 	}
2301 
2302 	ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2303 }
2304 
2305 /**
2306  * ipr_log_sis64_array_error - Log a sis64 array error.
2307  * @ioa_cfg:	ioa config struct
2308  * @hostrcb:	hostrcb struct
2309  *
2310  * Return value:
2311  * 	none
2312  **/
2313 static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2314 				      struct ipr_hostrcb *hostrcb)
2315 {
2316 	int i, num_entries;
2317 	struct ipr_hostrcb_type_24_error *error;
2318 	struct ipr_hostrcb64_array_data_entry *array_entry;
2319 	char buffer[IPR_MAX_RES_PATH_LENGTH];
2320 	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2321 
2322 	error = &hostrcb->hcam.u.error64.u.type_24_error;
2323 
2324 	ipr_err_separator;
2325 
2326 	ipr_err("RAID %s Array Configuration: %s\n",
2327 		error->protection_level,
2328 		ipr_format_res_path(ioa_cfg, error->last_res_path,
2329 			buffer, sizeof(buffer)));
2330 
2331 	ipr_err_separator;
2332 
2333 	array_entry = error->array_member;
2334 	num_entries = min_t(u32, error->num_entries,
2335 			    ARRAY_SIZE(error->array_member));
2336 
2337 	for (i = 0; i < num_entries; i++, array_entry++) {
2338 
2339 		if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2340 			continue;
2341 
2342 		if (error->exposed_mode_adn == i)
2343 			ipr_err("Exposed Array Member %d:\n", i);
2344 		else
2345 			ipr_err("Array Member %d:\n", i);
2346 
2347 		ipr_err("Array Member %d:\n", i);
2348 		ipr_log_ext_vpd(&array_entry->vpd);
2349 		ipr_err("Current Location: %s\n",
2350 			 ipr_format_res_path(ioa_cfg, array_entry->res_path,
2351 				buffer, sizeof(buffer)));
2352 		ipr_err("Expected Location: %s\n",
2353 			 ipr_format_res_path(ioa_cfg,
2354 				array_entry->expected_res_path,
2355 				buffer, sizeof(buffer)));
2356 
2357 		ipr_err_separator;
2358 	}
2359 }
2360 
2361 /**
2362  * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2363  * @ioa_cfg:	ioa config struct
2364  * @hostrcb:	hostrcb struct
2365  *
2366  * Return value:
2367  * 	none
2368  **/
2369 static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2370 				       struct ipr_hostrcb *hostrcb)
2371 {
2372 	struct ipr_hostrcb_type_30_error *error;
2373 	struct ipr_hostrcb64_fabric_desc *fabric;
2374 	struct ipr_hostrcb64_config_element *cfg;
2375 	int i, add_len;
2376 
2377 	error = &hostrcb->hcam.u.error64.u.type_30_error;
2378 
2379 	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2380 	ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2381 
2382 	add_len = be32_to_cpu(hostrcb->hcam.length) -
2383 		(offsetof(struct ipr_hostrcb64_error, u) +
2384 		 offsetof(struct ipr_hostrcb_type_30_error, desc));
2385 
2386 	for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2387 		ipr_log64_fabric_path(hostrcb, fabric);
2388 		for_each_fabric_cfg(fabric, cfg)
2389 			ipr_log64_path_elem(hostrcb, cfg);
2390 
2391 		add_len -= be16_to_cpu(fabric->length);
2392 		fabric = (struct ipr_hostrcb64_fabric_desc *)
2393 			((unsigned long)fabric + be16_to_cpu(fabric->length));
2394 	}
2395 
2396 	ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2397 }
2398 
2399 /**
2400  * ipr_log_sis64_service_required_error - Log a sis64 service required error.
2401  * @ioa_cfg:    ioa config struct
2402  * @hostrcb:    hostrcb struct
2403  *
2404  * Return value:
2405  *      none
2406  **/
2407 static void ipr_log_sis64_service_required_error(struct ipr_ioa_cfg *ioa_cfg,
2408 				       struct ipr_hostrcb *hostrcb)
2409 {
2410 	struct ipr_hostrcb_type_41_error *error;
2411 
2412 	error = &hostrcb->hcam.u.error64.u.type_41_error;
2413 
2414 	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2415 	ipr_err("Primary Failure Reason: %s\n", error->failure_reason);
2416 	ipr_log_hex_data(ioa_cfg, error->data,
2417 			 be32_to_cpu(hostrcb->hcam.length) -
2418 			 (offsetof(struct ipr_hostrcb_error, u) +
2419 			  offsetof(struct ipr_hostrcb_type_41_error, data)));
2420 }
2421 /**
2422  * ipr_log_generic_error - Log an adapter error.
2423  * @ioa_cfg:	ioa config struct
2424  * @hostrcb:	hostrcb struct
2425  *
2426  * Return value:
2427  * 	none
2428  **/
2429 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2430 				  struct ipr_hostrcb *hostrcb)
2431 {
2432 	ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2433 			 be32_to_cpu(hostrcb->hcam.length));
2434 }
2435 
2436 /**
2437  * ipr_log_sis64_device_error - Log a cache error.
2438  * @ioa_cfg:	ioa config struct
2439  * @hostrcb:	hostrcb struct
2440  *
2441  * Return value:
2442  * 	none
2443  **/
2444 static void ipr_log_sis64_device_error(struct ipr_ioa_cfg *ioa_cfg,
2445 					 struct ipr_hostrcb *hostrcb)
2446 {
2447 	struct ipr_hostrcb_type_21_error *error;
2448 	char buffer[IPR_MAX_RES_PATH_LENGTH];
2449 
2450 	error = &hostrcb->hcam.u.error64.u.type_21_error;
2451 
2452 	ipr_err("-----Failing Device Information-----\n");
2453 	ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
2454 		be32_to_cpu(error->wwn[0]), be32_to_cpu(error->wwn[1]),
2455 		 be32_to_cpu(error->wwn[2]), be32_to_cpu(error->wwn[3]));
2456 	ipr_err("Device Resource Path: %s\n",
2457 		__ipr_format_res_path(error->res_path,
2458 				      buffer, sizeof(buffer)));
2459 	error->primary_problem_desc[sizeof(error->primary_problem_desc) - 1] = '\0';
2460 	error->second_problem_desc[sizeof(error->second_problem_desc) - 1] = '\0';
2461 	ipr_err("Primary Problem Description: %s\n", error->primary_problem_desc);
2462 	ipr_err("Secondary Problem Description:  %s\n", error->second_problem_desc);
2463 	ipr_err("SCSI Sense Data:\n");
2464 	ipr_log_hex_data(ioa_cfg, error->sense_data, sizeof(error->sense_data));
2465 	ipr_err("SCSI Command Descriptor Block: \n");
2466 	ipr_log_hex_data(ioa_cfg, error->cdb, sizeof(error->cdb));
2467 
2468 	ipr_err("Additional IOA Data:\n");
2469 	ipr_log_hex_data(ioa_cfg, error->ioa_data, be32_to_cpu(error->length_of_error));
2470 }
2471 
2472 /**
2473  * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2474  * @ioasc:	IOASC
2475  *
2476  * This function will return the index of into the ipr_error_table
2477  * for the specified IOASC. If the IOASC is not in the table,
2478  * 0 will be returned, which points to the entry used for unknown errors.
2479  *
2480  * Return value:
2481  * 	index into the ipr_error_table
2482  **/
2483 static u32 ipr_get_error(u32 ioasc)
2484 {
2485 	int i;
2486 
2487 	for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2488 		if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2489 			return i;
2490 
2491 	return 0;
2492 }
2493 
2494 /**
2495  * ipr_handle_log_data - Log an adapter error.
2496  * @ioa_cfg:	ioa config struct
2497  * @hostrcb:	hostrcb struct
2498  *
2499  * This function logs an adapter error to the system.
2500  *
2501  * Return value:
2502  * 	none
2503  **/
2504 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2505 				struct ipr_hostrcb *hostrcb)
2506 {
2507 	u32 ioasc;
2508 	int error_index;
2509 	struct ipr_hostrcb_type_21_error *error;
2510 
2511 	if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2512 		return;
2513 
2514 	if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2515 		dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2516 
2517 	if (ioa_cfg->sis64)
2518 		ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2519 	else
2520 		ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2521 
2522 	if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2523 	    ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2524 		/* Tell the midlayer we had a bus reset so it will handle the UA properly */
2525 		scsi_report_bus_reset(ioa_cfg->host,
2526 				      hostrcb->hcam.u.error.fd_res_addr.bus);
2527 	}
2528 
2529 	error_index = ipr_get_error(ioasc);
2530 
2531 	if (!ipr_error_table[error_index].log_hcam)
2532 		return;
2533 
2534 	if (ioasc == IPR_IOASC_HW_CMD_FAILED &&
2535 	    hostrcb->hcam.overlay_id == IPR_HOST_RCB_OVERLAY_ID_21) {
2536 		error = &hostrcb->hcam.u.error64.u.type_21_error;
2537 
2538 		if (((be32_to_cpu(error->sense_data[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST &&
2539 			ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
2540 				return;
2541 	}
2542 
2543 	ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2544 
2545 	/* Set indication we have logged an error */
2546 	ioa_cfg->errors_logged++;
2547 
2548 	if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2549 		return;
2550 	if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2551 		hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2552 
2553 	switch (hostrcb->hcam.overlay_id) {
2554 	case IPR_HOST_RCB_OVERLAY_ID_2:
2555 		ipr_log_cache_error(ioa_cfg, hostrcb);
2556 		break;
2557 	case IPR_HOST_RCB_OVERLAY_ID_3:
2558 		ipr_log_config_error(ioa_cfg, hostrcb);
2559 		break;
2560 	case IPR_HOST_RCB_OVERLAY_ID_4:
2561 	case IPR_HOST_RCB_OVERLAY_ID_6:
2562 		ipr_log_array_error(ioa_cfg, hostrcb);
2563 		break;
2564 	case IPR_HOST_RCB_OVERLAY_ID_7:
2565 		ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2566 		break;
2567 	case IPR_HOST_RCB_OVERLAY_ID_12:
2568 		ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2569 		break;
2570 	case IPR_HOST_RCB_OVERLAY_ID_13:
2571 		ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2572 		break;
2573 	case IPR_HOST_RCB_OVERLAY_ID_14:
2574 	case IPR_HOST_RCB_OVERLAY_ID_16:
2575 		ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2576 		break;
2577 	case IPR_HOST_RCB_OVERLAY_ID_17:
2578 		ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2579 		break;
2580 	case IPR_HOST_RCB_OVERLAY_ID_20:
2581 		ipr_log_fabric_error(ioa_cfg, hostrcb);
2582 		break;
2583 	case IPR_HOST_RCB_OVERLAY_ID_21:
2584 		ipr_log_sis64_device_error(ioa_cfg, hostrcb);
2585 		break;
2586 	case IPR_HOST_RCB_OVERLAY_ID_23:
2587 		ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2588 		break;
2589 	case IPR_HOST_RCB_OVERLAY_ID_24:
2590 	case IPR_HOST_RCB_OVERLAY_ID_26:
2591 		ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2592 		break;
2593 	case IPR_HOST_RCB_OVERLAY_ID_30:
2594 		ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2595 		break;
2596 	case IPR_HOST_RCB_OVERLAY_ID_41:
2597 		ipr_log_sis64_service_required_error(ioa_cfg, hostrcb);
2598 		break;
2599 	case IPR_HOST_RCB_OVERLAY_ID_1:
2600 	case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2601 	default:
2602 		ipr_log_generic_error(ioa_cfg, hostrcb);
2603 		break;
2604 	}
2605 }
2606 
2607 static struct ipr_hostrcb *ipr_get_free_hostrcb(struct ipr_ioa_cfg *ioa)
2608 {
2609 	struct ipr_hostrcb *hostrcb;
2610 
2611 	hostrcb = list_first_entry_or_null(&ioa->hostrcb_free_q,
2612 					struct ipr_hostrcb, queue);
2613 
2614 	if (unlikely(!hostrcb)) {
2615 		dev_info(&ioa->pdev->dev, "Reclaiming async error buffers.");
2616 		hostrcb = list_first_entry_or_null(&ioa->hostrcb_report_q,
2617 						struct ipr_hostrcb, queue);
2618 	}
2619 
2620 	list_del_init(&hostrcb->queue);
2621 	return hostrcb;
2622 }
2623 
2624 /**
2625  * ipr_process_error - Op done function for an adapter error log.
2626  * @ipr_cmd:	ipr command struct
2627  *
2628  * This function is the op done function for an error log host
2629  * controlled async from the adapter. It will log the error and
2630  * send the HCAM back to the adapter.
2631  *
2632  * Return value:
2633  * 	none
2634  **/
2635 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2636 {
2637 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2638 	struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2639 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2640 	u32 fd_ioasc;
2641 
2642 	if (ioa_cfg->sis64)
2643 		fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2644 	else
2645 		fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2646 
2647 	list_del_init(&hostrcb->queue);
2648 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
2649 
2650 	if (!ioasc) {
2651 		ipr_handle_log_data(ioa_cfg, hostrcb);
2652 		if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2653 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2654 	} else if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
2655 		   ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) {
2656 		dev_err(&ioa_cfg->pdev->dev,
2657 			"Host RCB failed with IOASC: 0x%08X\n", ioasc);
2658 	}
2659 
2660 	list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_report_q);
2661 	schedule_work(&ioa_cfg->work_q);
2662 	hostrcb = ipr_get_free_hostrcb(ioa_cfg);
2663 
2664 	ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2665 }
2666 
2667 /**
2668  * ipr_timeout -  An internally generated op has timed out.
2669  * @t: Timer context used to fetch ipr command struct
2670  *
2671  * This function blocks host requests and initiates an
2672  * adapter reset.
2673  *
2674  * Return value:
2675  * 	none
2676  **/
2677 static void ipr_timeout(struct timer_list *t)
2678 {
2679 	struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2680 	unsigned long lock_flags = 0;
2681 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2682 
2683 	ENTER;
2684 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2685 
2686 	ioa_cfg->errors_logged++;
2687 	dev_err(&ioa_cfg->pdev->dev,
2688 		"Adapter being reset due to command timeout.\n");
2689 
2690 	if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2691 		ioa_cfg->sdt_state = GET_DUMP;
2692 
2693 	if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2694 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2695 
2696 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2697 	LEAVE;
2698 }
2699 
2700 /**
2701  * ipr_oper_timeout -  Adapter timed out transitioning to operational
2702  * @t: Timer context used to fetch ipr command struct
2703  *
2704  * This function blocks host requests and initiates an
2705  * adapter reset.
2706  *
2707  * Return value:
2708  * 	none
2709  **/
2710 static void ipr_oper_timeout(struct timer_list *t)
2711 {
2712 	struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2713 	unsigned long lock_flags = 0;
2714 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2715 
2716 	ENTER;
2717 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2718 
2719 	ioa_cfg->errors_logged++;
2720 	dev_err(&ioa_cfg->pdev->dev,
2721 		"Adapter timed out transitioning to operational.\n");
2722 
2723 	if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2724 		ioa_cfg->sdt_state = GET_DUMP;
2725 
2726 	if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2727 		if (ipr_fastfail)
2728 			ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2729 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2730 	}
2731 
2732 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2733 	LEAVE;
2734 }
2735 
2736 /**
2737  * ipr_find_ses_entry - Find matching SES in SES table
2738  * @res:	resource entry struct of SES
2739  *
2740  * Return value:
2741  * 	pointer to SES table entry / NULL on failure
2742  **/
2743 static const struct ipr_ses_table_entry *
2744 ipr_find_ses_entry(struct ipr_resource_entry *res)
2745 {
2746 	int i, j, matches;
2747 	struct ipr_std_inq_vpids *vpids;
2748 	const struct ipr_ses_table_entry *ste = ipr_ses_table;
2749 
2750 	for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2751 		for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2752 			if (ste->compare_product_id_byte[j] == 'X') {
2753 				vpids = &res->std_inq_data.vpids;
2754 				if (vpids->product_id[j] == ste->product_id[j])
2755 					matches++;
2756 				else
2757 					break;
2758 			} else
2759 				matches++;
2760 		}
2761 
2762 		if (matches == IPR_PROD_ID_LEN)
2763 			return ste;
2764 	}
2765 
2766 	return NULL;
2767 }
2768 
2769 /**
2770  * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2771  * @ioa_cfg:	ioa config struct
2772  * @bus:		SCSI bus
2773  * @bus_width:	bus width
2774  *
2775  * Return value:
2776  *	SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2777  *	For a 2-byte wide SCSI bus, the maximum transfer speed is
2778  *	twice the maximum transfer rate (e.g. for a wide enabled bus,
2779  *	max 160MHz = max 320MB/sec).
2780  **/
2781 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2782 {
2783 	struct ipr_resource_entry *res;
2784 	const struct ipr_ses_table_entry *ste;
2785 	u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2786 
2787 	/* Loop through each config table entry in the config table buffer */
2788 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2789 		if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2790 			continue;
2791 
2792 		if (bus != res->bus)
2793 			continue;
2794 
2795 		if (!(ste = ipr_find_ses_entry(res)))
2796 			continue;
2797 
2798 		max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2799 	}
2800 
2801 	return max_xfer_rate;
2802 }
2803 
2804 /**
2805  * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2806  * @ioa_cfg:		ioa config struct
2807  * @max_delay:		max delay in micro-seconds to wait
2808  *
2809  * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2810  *
2811  * Return value:
2812  * 	0 on success / other on failure
2813  **/
2814 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2815 {
2816 	volatile u32 pcii_reg;
2817 	int delay = 1;
2818 
2819 	/* Read interrupt reg until IOA signals IO Debug Acknowledge */
2820 	while (delay < max_delay) {
2821 		pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2822 
2823 		if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2824 			return 0;
2825 
2826 		/* udelay cannot be used if delay is more than a few milliseconds */
2827 		if ((delay / 1000) > MAX_UDELAY_MS)
2828 			mdelay(delay / 1000);
2829 		else
2830 			udelay(delay);
2831 
2832 		delay += delay;
2833 	}
2834 	return -EIO;
2835 }
2836 
2837 /**
2838  * ipr_get_sis64_dump_data_section - Dump IOA memory
2839  * @ioa_cfg:			ioa config struct
2840  * @start_addr:			adapter address to dump
2841  * @dest:			destination kernel buffer
2842  * @length_in_words:		length to dump in 4 byte words
2843  *
2844  * Return value:
2845  * 	0 on success
2846  **/
2847 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2848 					   u32 start_addr,
2849 					   __be32 *dest, u32 length_in_words)
2850 {
2851 	int i;
2852 
2853 	for (i = 0; i < length_in_words; i++) {
2854 		writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2855 		*dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2856 		dest++;
2857 	}
2858 
2859 	return 0;
2860 }
2861 
2862 /**
2863  * ipr_get_ldump_data_section - Dump IOA memory
2864  * @ioa_cfg:			ioa config struct
2865  * @start_addr:			adapter address to dump
2866  * @dest:				destination kernel buffer
2867  * @length_in_words:	length to dump in 4 byte words
2868  *
2869  * Return value:
2870  * 	0 on success / -EIO on failure
2871  **/
2872 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2873 				      u32 start_addr,
2874 				      __be32 *dest, u32 length_in_words)
2875 {
2876 	volatile u32 temp_pcii_reg;
2877 	int i, delay = 0;
2878 
2879 	if (ioa_cfg->sis64)
2880 		return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2881 						       dest, length_in_words);
2882 
2883 	/* Write IOA interrupt reg starting LDUMP state  */
2884 	writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2885 	       ioa_cfg->regs.set_uproc_interrupt_reg32);
2886 
2887 	/* Wait for IO debug acknowledge */
2888 	if (ipr_wait_iodbg_ack(ioa_cfg,
2889 			       IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2890 		dev_err(&ioa_cfg->pdev->dev,
2891 			"IOA dump long data transfer timeout\n");
2892 		return -EIO;
2893 	}
2894 
2895 	/* Signal LDUMP interlocked - clear IO debug ack */
2896 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2897 	       ioa_cfg->regs.clr_interrupt_reg);
2898 
2899 	/* Write Mailbox with starting address */
2900 	writel(start_addr, ioa_cfg->ioa_mailbox);
2901 
2902 	/* Signal address valid - clear IOA Reset alert */
2903 	writel(IPR_UPROCI_RESET_ALERT,
2904 	       ioa_cfg->regs.clr_uproc_interrupt_reg32);
2905 
2906 	for (i = 0; i < length_in_words; i++) {
2907 		/* Wait for IO debug acknowledge */
2908 		if (ipr_wait_iodbg_ack(ioa_cfg,
2909 				       IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2910 			dev_err(&ioa_cfg->pdev->dev,
2911 				"IOA dump short data transfer timeout\n");
2912 			return -EIO;
2913 		}
2914 
2915 		/* Read data from mailbox and increment destination pointer */
2916 		*dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2917 		dest++;
2918 
2919 		/* For all but the last word of data, signal data received */
2920 		if (i < (length_in_words - 1)) {
2921 			/* Signal dump data received - Clear IO debug Ack */
2922 			writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2923 			       ioa_cfg->regs.clr_interrupt_reg);
2924 		}
2925 	}
2926 
2927 	/* Signal end of block transfer. Set reset alert then clear IO debug ack */
2928 	writel(IPR_UPROCI_RESET_ALERT,
2929 	       ioa_cfg->regs.set_uproc_interrupt_reg32);
2930 
2931 	writel(IPR_UPROCI_IO_DEBUG_ALERT,
2932 	       ioa_cfg->regs.clr_uproc_interrupt_reg32);
2933 
2934 	/* Signal dump data received - Clear IO debug Ack */
2935 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2936 	       ioa_cfg->regs.clr_interrupt_reg);
2937 
2938 	/* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2939 	while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2940 		temp_pcii_reg =
2941 		    readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2942 
2943 		if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2944 			return 0;
2945 
2946 		udelay(10);
2947 		delay += 10;
2948 	}
2949 
2950 	return 0;
2951 }
2952 
2953 #ifdef CONFIG_SCSI_IPR_DUMP
2954 /**
2955  * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2956  * @ioa_cfg:		ioa config struct
2957  * @pci_address:	adapter address
2958  * @length:			length of data to copy
2959  *
2960  * Copy data from PCI adapter to kernel buffer.
2961  * Note: length MUST be a 4 byte multiple
2962  * Return value:
2963  * 	0 on success / other on failure
2964  **/
2965 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2966 			unsigned long pci_address, u32 length)
2967 {
2968 	int bytes_copied = 0;
2969 	int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2970 	__be32 *page;
2971 	unsigned long lock_flags = 0;
2972 	struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2973 
2974 	if (ioa_cfg->sis64)
2975 		max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2976 	else
2977 		max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2978 
2979 	while (bytes_copied < length &&
2980 	       (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2981 		if (ioa_dump->page_offset >= PAGE_SIZE ||
2982 		    ioa_dump->page_offset == 0) {
2983 			page = (__be32 *)__get_free_page(GFP_ATOMIC);
2984 
2985 			if (!page) {
2986 				ipr_trace;
2987 				return bytes_copied;
2988 			}
2989 
2990 			ioa_dump->page_offset = 0;
2991 			ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2992 			ioa_dump->next_page_index++;
2993 		} else
2994 			page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2995 
2996 		rem_len = length - bytes_copied;
2997 		rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2998 		cur_len = min(rem_len, rem_page_len);
2999 
3000 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3001 		if (ioa_cfg->sdt_state == ABORT_DUMP) {
3002 			rc = -EIO;
3003 		} else {
3004 			rc = ipr_get_ldump_data_section(ioa_cfg,
3005 							pci_address + bytes_copied,
3006 							&page[ioa_dump->page_offset / 4],
3007 							(cur_len / sizeof(u32)));
3008 		}
3009 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3010 
3011 		if (!rc) {
3012 			ioa_dump->page_offset += cur_len;
3013 			bytes_copied += cur_len;
3014 		} else {
3015 			ipr_trace;
3016 			break;
3017 		}
3018 		schedule();
3019 	}
3020 
3021 	return bytes_copied;
3022 }
3023 
3024 /**
3025  * ipr_init_dump_entry_hdr - Initialize a dump entry header.
3026  * @hdr:	dump entry header struct
3027  *
3028  * Return value:
3029  * 	nothing
3030  **/
3031 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
3032 {
3033 	hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
3034 	hdr->num_elems = 1;
3035 	hdr->offset = sizeof(*hdr);
3036 	hdr->status = IPR_DUMP_STATUS_SUCCESS;
3037 }
3038 
3039 /**
3040  * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
3041  * @ioa_cfg:	ioa config struct
3042  * @driver_dump:	driver dump struct
3043  *
3044  * Return value:
3045  * 	nothing
3046  **/
3047 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
3048 				   struct ipr_driver_dump *driver_dump)
3049 {
3050 	struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3051 
3052 	ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
3053 	driver_dump->ioa_type_entry.hdr.len =
3054 		sizeof(struct ipr_dump_ioa_type_entry) -
3055 		sizeof(struct ipr_dump_entry_header);
3056 	driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3057 	driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
3058 	driver_dump->ioa_type_entry.type = ioa_cfg->type;
3059 	driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
3060 		(ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
3061 		ucode_vpd->minor_release[1];
3062 	driver_dump->hdr.num_entries++;
3063 }
3064 
3065 /**
3066  * ipr_dump_version_data - Fill in the driver version in the dump.
3067  * @ioa_cfg:	ioa config struct
3068  * @driver_dump:	driver dump struct
3069  *
3070  * Return value:
3071  * 	nothing
3072  **/
3073 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
3074 				  struct ipr_driver_dump *driver_dump)
3075 {
3076 	ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
3077 	driver_dump->version_entry.hdr.len =
3078 		sizeof(struct ipr_dump_version_entry) -
3079 		sizeof(struct ipr_dump_entry_header);
3080 	driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3081 	driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
3082 	strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
3083 	driver_dump->hdr.num_entries++;
3084 }
3085 
3086 /**
3087  * ipr_dump_trace_data - Fill in the IOA trace in the dump.
3088  * @ioa_cfg:	ioa config struct
3089  * @driver_dump:	driver dump struct
3090  *
3091  * Return value:
3092  * 	nothing
3093  **/
3094 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
3095 				   struct ipr_driver_dump *driver_dump)
3096 {
3097 	ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
3098 	driver_dump->trace_entry.hdr.len =
3099 		sizeof(struct ipr_dump_trace_entry) -
3100 		sizeof(struct ipr_dump_entry_header);
3101 	driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3102 	driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
3103 	memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
3104 	driver_dump->hdr.num_entries++;
3105 }
3106 
3107 /**
3108  * ipr_dump_location_data - Fill in the IOA location in the dump.
3109  * @ioa_cfg:	ioa config struct
3110  * @driver_dump:	driver dump struct
3111  *
3112  * Return value:
3113  * 	nothing
3114  **/
3115 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
3116 				   struct ipr_driver_dump *driver_dump)
3117 {
3118 	ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
3119 	driver_dump->location_entry.hdr.len =
3120 		sizeof(struct ipr_dump_location_entry) -
3121 		sizeof(struct ipr_dump_entry_header);
3122 	driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3123 	driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
3124 	strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
3125 	driver_dump->hdr.num_entries++;
3126 }
3127 
3128 /**
3129  * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
3130  * @ioa_cfg:	ioa config struct
3131  * @dump:		dump struct
3132  *
3133  * Return value:
3134  * 	nothing
3135  **/
3136 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
3137 {
3138 	unsigned long start_addr, sdt_word;
3139 	unsigned long lock_flags = 0;
3140 	struct ipr_driver_dump *driver_dump = &dump->driver_dump;
3141 	struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
3142 	u32 num_entries, max_num_entries, start_off, end_off;
3143 	u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
3144 	struct ipr_sdt *sdt;
3145 	int valid = 1;
3146 	int i;
3147 
3148 	ENTER;
3149 
3150 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3151 
3152 	if (ioa_cfg->sdt_state != READ_DUMP) {
3153 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3154 		return;
3155 	}
3156 
3157 	if (ioa_cfg->sis64) {
3158 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3159 		ssleep(IPR_DUMP_DELAY_SECONDS);
3160 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3161 	}
3162 
3163 	start_addr = readl(ioa_cfg->ioa_mailbox);
3164 
3165 	if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
3166 		dev_err(&ioa_cfg->pdev->dev,
3167 			"Invalid dump table format: %lx\n", start_addr);
3168 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3169 		return;
3170 	}
3171 
3172 	dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
3173 
3174 	driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
3175 
3176 	/* Initialize the overall dump header */
3177 	driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
3178 	driver_dump->hdr.num_entries = 1;
3179 	driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
3180 	driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
3181 	driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
3182 	driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
3183 
3184 	ipr_dump_version_data(ioa_cfg, driver_dump);
3185 	ipr_dump_location_data(ioa_cfg, driver_dump);
3186 	ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
3187 	ipr_dump_trace_data(ioa_cfg, driver_dump);
3188 
3189 	/* Update dump_header */
3190 	driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
3191 
3192 	/* IOA Dump entry */
3193 	ipr_init_dump_entry_hdr(&ioa_dump->hdr);
3194 	ioa_dump->hdr.len = 0;
3195 	ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3196 	ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
3197 
3198 	/* First entries in sdt are actually a list of dump addresses and
3199 	 lengths to gather the real dump data.  sdt represents the pointer
3200 	 to the ioa generated dump table.  Dump data will be extracted based
3201 	 on entries in this table */
3202 	sdt = &ioa_dump->sdt;
3203 
3204 	if (ioa_cfg->sis64) {
3205 		max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
3206 		max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
3207 	} else {
3208 		max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
3209 		max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
3210 	}
3211 
3212 	bytes_to_copy = offsetof(struct ipr_sdt, entry) +
3213 			(max_num_entries * sizeof(struct ipr_sdt_entry));
3214 	rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
3215 					bytes_to_copy / sizeof(__be32));
3216 
3217 	/* Smart Dump table is ready to use and the first entry is valid */
3218 	if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
3219 	    (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
3220 		dev_err(&ioa_cfg->pdev->dev,
3221 			"Dump of IOA failed. Dump table not valid: %d, %X.\n",
3222 			rc, be32_to_cpu(sdt->hdr.state));
3223 		driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
3224 		ioa_cfg->sdt_state = DUMP_OBTAINED;
3225 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3226 		return;
3227 	}
3228 
3229 	num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
3230 
3231 	if (num_entries > max_num_entries)
3232 		num_entries = max_num_entries;
3233 
3234 	/* Update dump length to the actual data to be copied */
3235 	dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
3236 	if (ioa_cfg->sis64)
3237 		dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
3238 	else
3239 		dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
3240 
3241 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3242 
3243 	for (i = 0; i < num_entries; i++) {
3244 		if (ioa_dump->hdr.len > max_dump_size) {
3245 			driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3246 			break;
3247 		}
3248 
3249 		if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3250 			sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3251 			if (ioa_cfg->sis64)
3252 				bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3253 			else {
3254 				start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3255 				end_off = be32_to_cpu(sdt->entry[i].end_token);
3256 
3257 				if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3258 					bytes_to_copy = end_off - start_off;
3259 				else
3260 					valid = 0;
3261 			}
3262 			if (valid) {
3263 				if (bytes_to_copy > max_dump_size) {
3264 					sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3265 					continue;
3266 				}
3267 
3268 				/* Copy data from adapter to driver buffers */
3269 				bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3270 							    bytes_to_copy);
3271 
3272 				ioa_dump->hdr.len += bytes_copied;
3273 
3274 				if (bytes_copied != bytes_to_copy) {
3275 					driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3276 					break;
3277 				}
3278 			}
3279 		}
3280 	}
3281 
3282 	dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3283 
3284 	/* Update dump_header */
3285 	driver_dump->hdr.len += ioa_dump->hdr.len;
3286 	wmb();
3287 	ioa_cfg->sdt_state = DUMP_OBTAINED;
3288 	LEAVE;
3289 }
3290 
3291 #else
3292 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3293 #endif
3294 
3295 /**
3296  * ipr_release_dump - Free adapter dump memory
3297  * @kref:	kref struct
3298  *
3299  * Return value:
3300  *	nothing
3301  **/
3302 static void ipr_release_dump(struct kref *kref)
3303 {
3304 	struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3305 	struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3306 	unsigned long lock_flags = 0;
3307 	int i;
3308 
3309 	ENTER;
3310 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3311 	ioa_cfg->dump = NULL;
3312 	ioa_cfg->sdt_state = INACTIVE;
3313 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3314 
3315 	for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3316 		free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3317 
3318 	vfree(dump->ioa_dump.ioa_data);
3319 	kfree(dump);
3320 	LEAVE;
3321 }
3322 
3323 static void ipr_add_remove_thread(struct work_struct *work)
3324 {
3325 	unsigned long lock_flags;
3326 	struct ipr_resource_entry *res;
3327 	struct scsi_device *sdev;
3328 	struct ipr_ioa_cfg *ioa_cfg =
3329 		container_of(work, struct ipr_ioa_cfg, scsi_add_work_q);
3330 	u8 bus, target, lun;
3331 	int did_work;
3332 
3333 	ENTER;
3334 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3335 
3336 restart:
3337 	do {
3338 		did_work = 0;
3339 		if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
3340 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3341 			return;
3342 		}
3343 
3344 		list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3345 			if (res->del_from_ml && res->sdev) {
3346 				did_work = 1;
3347 				sdev = res->sdev;
3348 				if (!scsi_device_get(sdev)) {
3349 					if (!res->add_to_ml)
3350 						list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3351 					else
3352 						res->del_from_ml = 0;
3353 					spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3354 					scsi_remove_device(sdev);
3355 					scsi_device_put(sdev);
3356 					spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3357 				}
3358 				break;
3359 			}
3360 		}
3361 	} while (did_work);
3362 
3363 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3364 		if (res->add_to_ml) {
3365 			bus = res->bus;
3366 			target = res->target;
3367 			lun = res->lun;
3368 			res->add_to_ml = 0;
3369 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3370 			scsi_add_device(ioa_cfg->host, bus, target, lun);
3371 			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3372 			goto restart;
3373 		}
3374 	}
3375 
3376 	ioa_cfg->scan_done = 1;
3377 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3378 	kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3379 	LEAVE;
3380 }
3381 
3382 /**
3383  * ipr_worker_thread - Worker thread
3384  * @work:		ioa config struct
3385  *
3386  * Called at task level from a work thread. This function takes care
3387  * of adding and removing device from the mid-layer as configuration
3388  * changes are detected by the adapter.
3389  *
3390  * Return value:
3391  * 	nothing
3392  **/
3393 static void ipr_worker_thread(struct work_struct *work)
3394 {
3395 	unsigned long lock_flags;
3396 	struct ipr_dump *dump;
3397 	struct ipr_ioa_cfg *ioa_cfg =
3398 		container_of(work, struct ipr_ioa_cfg, work_q);
3399 
3400 	ENTER;
3401 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3402 
3403 	if (ioa_cfg->sdt_state == READ_DUMP) {
3404 		dump = ioa_cfg->dump;
3405 		if (!dump) {
3406 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3407 			return;
3408 		}
3409 		kref_get(&dump->kref);
3410 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3411 		ipr_get_ioa_dump(ioa_cfg, dump);
3412 		kref_put(&dump->kref, ipr_release_dump);
3413 
3414 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3415 		if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3416 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3417 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3418 		return;
3419 	}
3420 
3421 	if (ioa_cfg->scsi_unblock) {
3422 		ioa_cfg->scsi_unblock = 0;
3423 		ioa_cfg->scsi_blocked = 0;
3424 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3425 		scsi_unblock_requests(ioa_cfg->host);
3426 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3427 		if (ioa_cfg->scsi_blocked)
3428 			scsi_block_requests(ioa_cfg->host);
3429 	}
3430 
3431 	if (!ioa_cfg->scan_enabled) {
3432 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3433 		return;
3434 	}
3435 
3436 	schedule_work(&ioa_cfg->scsi_add_work_q);
3437 
3438 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3439 	LEAVE;
3440 }
3441 
3442 #ifdef CONFIG_SCSI_IPR_TRACE
3443 /**
3444  * ipr_read_trace - Dump the adapter trace
3445  * @filp:		open sysfs file
3446  * @kobj:		kobject struct
3447  * @bin_attr:		bin_attribute struct
3448  * @buf:		buffer
3449  * @off:		offset
3450  * @count:		buffer size
3451  *
3452  * Return value:
3453  *	number of bytes printed to buffer
3454  **/
3455 static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3456 			      struct bin_attribute *bin_attr,
3457 			      char *buf, loff_t off, size_t count)
3458 {
3459 	struct device *dev = container_of(kobj, struct device, kobj);
3460 	struct Scsi_Host *shost = class_to_shost(dev);
3461 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3462 	unsigned long lock_flags = 0;
3463 	ssize_t ret;
3464 
3465 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3466 	ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3467 				IPR_TRACE_SIZE);
3468 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3469 
3470 	return ret;
3471 }
3472 
3473 static struct bin_attribute ipr_trace_attr = {
3474 	.attr =	{
3475 		.name = "trace",
3476 		.mode = S_IRUGO,
3477 	},
3478 	.size = 0,
3479 	.read = ipr_read_trace,
3480 };
3481 #endif
3482 
3483 /**
3484  * ipr_show_fw_version - Show the firmware version
3485  * @dev:	class device struct
3486  * @attr:	device attribute (unused)
3487  * @buf:	buffer
3488  *
3489  * Return value:
3490  *	number of bytes printed to buffer
3491  **/
3492 static ssize_t ipr_show_fw_version(struct device *dev,
3493 				   struct device_attribute *attr, char *buf)
3494 {
3495 	struct Scsi_Host *shost = class_to_shost(dev);
3496 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3497 	struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3498 	unsigned long lock_flags = 0;
3499 	int len;
3500 
3501 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3502 	len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3503 		       ucode_vpd->major_release, ucode_vpd->card_type,
3504 		       ucode_vpd->minor_release[0],
3505 		       ucode_vpd->minor_release[1]);
3506 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3507 	return len;
3508 }
3509 
3510 static struct device_attribute ipr_fw_version_attr = {
3511 	.attr = {
3512 		.name =		"fw_version",
3513 		.mode =		S_IRUGO,
3514 	},
3515 	.show = ipr_show_fw_version,
3516 };
3517 
3518 /**
3519  * ipr_show_log_level - Show the adapter's error logging level
3520  * @dev:	class device struct
3521  * @attr:	device attribute (unused)
3522  * @buf:	buffer
3523  *
3524  * Return value:
3525  * 	number of bytes printed to buffer
3526  **/
3527 static ssize_t ipr_show_log_level(struct device *dev,
3528 				   struct device_attribute *attr, char *buf)
3529 {
3530 	struct Scsi_Host *shost = class_to_shost(dev);
3531 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3532 	unsigned long lock_flags = 0;
3533 	int len;
3534 
3535 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3536 	len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3537 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3538 	return len;
3539 }
3540 
3541 /**
3542  * ipr_store_log_level - Change the adapter's error logging level
3543  * @dev:	class device struct
3544  * @attr:	device attribute (unused)
3545  * @buf:	buffer
3546  * @count:	buffer size
3547  *
3548  * Return value:
3549  * 	number of bytes printed to buffer
3550  **/
3551 static ssize_t ipr_store_log_level(struct device *dev,
3552 				   struct device_attribute *attr,
3553 				   const char *buf, size_t count)
3554 {
3555 	struct Scsi_Host *shost = class_to_shost(dev);
3556 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3557 	unsigned long lock_flags = 0;
3558 
3559 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3560 	ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3561 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3562 	return strlen(buf);
3563 }
3564 
3565 static struct device_attribute ipr_log_level_attr = {
3566 	.attr = {
3567 		.name =		"log_level",
3568 		.mode =		S_IRUGO | S_IWUSR,
3569 	},
3570 	.show = ipr_show_log_level,
3571 	.store = ipr_store_log_level
3572 };
3573 
3574 /**
3575  * ipr_store_diagnostics - IOA Diagnostics interface
3576  * @dev:	device struct
3577  * @attr:	device attribute (unused)
3578  * @buf:	buffer
3579  * @count:	buffer size
3580  *
3581  * This function will reset the adapter and wait a reasonable
3582  * amount of time for any errors that the adapter might log.
3583  *
3584  * Return value:
3585  * 	count on success / other on failure
3586  **/
3587 static ssize_t ipr_store_diagnostics(struct device *dev,
3588 				     struct device_attribute *attr,
3589 				     const char *buf, size_t count)
3590 {
3591 	struct Scsi_Host *shost = class_to_shost(dev);
3592 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3593 	unsigned long lock_flags = 0;
3594 	int rc = count;
3595 
3596 	if (!capable(CAP_SYS_ADMIN))
3597 		return -EACCES;
3598 
3599 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3600 	while (ioa_cfg->in_reset_reload) {
3601 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3602 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3603 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3604 	}
3605 
3606 	ioa_cfg->errors_logged = 0;
3607 	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3608 
3609 	if (ioa_cfg->in_reset_reload) {
3610 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3611 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3612 
3613 		/* Wait for a second for any errors to be logged */
3614 		msleep(1000);
3615 	} else {
3616 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3617 		return -EIO;
3618 	}
3619 
3620 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3621 	if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3622 		rc = -EIO;
3623 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3624 
3625 	return rc;
3626 }
3627 
3628 static struct device_attribute ipr_diagnostics_attr = {
3629 	.attr = {
3630 		.name =		"run_diagnostics",
3631 		.mode =		S_IWUSR,
3632 	},
3633 	.store = ipr_store_diagnostics
3634 };
3635 
3636 /**
3637  * ipr_show_adapter_state - Show the adapter's state
3638  * @dev:	device struct
3639  * @attr:	device attribute (unused)
3640  * @buf:	buffer
3641  *
3642  * Return value:
3643  * 	number of bytes printed to buffer
3644  **/
3645 static ssize_t ipr_show_adapter_state(struct device *dev,
3646 				      struct device_attribute *attr, char *buf)
3647 {
3648 	struct Scsi_Host *shost = class_to_shost(dev);
3649 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3650 	unsigned long lock_flags = 0;
3651 	int len;
3652 
3653 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3654 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
3655 		len = snprintf(buf, PAGE_SIZE, "offline\n");
3656 	else
3657 		len = snprintf(buf, PAGE_SIZE, "online\n");
3658 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3659 	return len;
3660 }
3661 
3662 /**
3663  * ipr_store_adapter_state - Change adapter state
3664  * @dev:	device struct
3665  * @attr:	device attribute (unused)
3666  * @buf:	buffer
3667  * @count:	buffer size
3668  *
3669  * This function will change the adapter's state.
3670  *
3671  * Return value:
3672  * 	count on success / other on failure
3673  **/
3674 static ssize_t ipr_store_adapter_state(struct device *dev,
3675 				       struct device_attribute *attr,
3676 				       const char *buf, size_t count)
3677 {
3678 	struct Scsi_Host *shost = class_to_shost(dev);
3679 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3680 	unsigned long lock_flags;
3681 	int result = count, i;
3682 
3683 	if (!capable(CAP_SYS_ADMIN))
3684 		return -EACCES;
3685 
3686 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3687 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead &&
3688 	    !strncmp(buf, "online", 6)) {
3689 		for (i = 0; i < ioa_cfg->hrrq_num; i++) {
3690 			spin_lock(&ioa_cfg->hrrq[i]._lock);
3691 			ioa_cfg->hrrq[i].ioa_is_dead = 0;
3692 			spin_unlock(&ioa_cfg->hrrq[i]._lock);
3693 		}
3694 		wmb();
3695 		ioa_cfg->reset_retries = 0;
3696 		ioa_cfg->in_ioa_bringdown = 0;
3697 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3698 	}
3699 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3700 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3701 
3702 	return result;
3703 }
3704 
3705 static struct device_attribute ipr_ioa_state_attr = {
3706 	.attr = {
3707 		.name =		"online_state",
3708 		.mode =		S_IRUGO | S_IWUSR,
3709 	},
3710 	.show = ipr_show_adapter_state,
3711 	.store = ipr_store_adapter_state
3712 };
3713 
3714 /**
3715  * ipr_store_reset_adapter - Reset the adapter
3716  * @dev:	device struct
3717  * @attr:	device attribute (unused)
3718  * @buf:	buffer
3719  * @count:	buffer size
3720  *
3721  * This function will reset the adapter.
3722  *
3723  * Return value:
3724  * 	count on success / other on failure
3725  **/
3726 static ssize_t ipr_store_reset_adapter(struct device *dev,
3727 				       struct device_attribute *attr,
3728 				       const char *buf, size_t count)
3729 {
3730 	struct Scsi_Host *shost = class_to_shost(dev);
3731 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3732 	unsigned long lock_flags;
3733 	int result = count;
3734 
3735 	if (!capable(CAP_SYS_ADMIN))
3736 		return -EACCES;
3737 
3738 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3739 	if (!ioa_cfg->in_reset_reload)
3740 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3741 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3742 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3743 
3744 	return result;
3745 }
3746 
3747 static struct device_attribute ipr_ioa_reset_attr = {
3748 	.attr = {
3749 		.name =		"reset_host",
3750 		.mode =		S_IWUSR,
3751 	},
3752 	.store = ipr_store_reset_adapter
3753 };
3754 
3755 static int ipr_iopoll(struct irq_poll *iop, int budget);
3756  /**
3757  * ipr_show_iopoll_weight - Show ipr polling mode
3758  * @dev:	class device struct
3759  * @attr:	device attribute (unused)
3760  * @buf:	buffer
3761  *
3762  * Return value:
3763  *	number of bytes printed to buffer
3764  **/
3765 static ssize_t ipr_show_iopoll_weight(struct device *dev,
3766 				   struct device_attribute *attr, char *buf)
3767 {
3768 	struct Scsi_Host *shost = class_to_shost(dev);
3769 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3770 	unsigned long lock_flags = 0;
3771 	int len;
3772 
3773 	spin_lock_irqsave(shost->host_lock, lock_flags);
3774 	len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight);
3775 	spin_unlock_irqrestore(shost->host_lock, lock_flags);
3776 
3777 	return len;
3778 }
3779 
3780 /**
3781  * ipr_store_iopoll_weight - Change the adapter's polling mode
3782  * @dev:	class device struct
3783  * @attr:	device attribute (unused)
3784  * @buf:	buffer
3785  * @count:	buffer size
3786  *
3787  * Return value:
3788  *	number of bytes printed to buffer
3789  **/
3790 static ssize_t ipr_store_iopoll_weight(struct device *dev,
3791 					struct device_attribute *attr,
3792 					const char *buf, size_t count)
3793 {
3794 	struct Scsi_Host *shost = class_to_shost(dev);
3795 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3796 	unsigned long user_iopoll_weight;
3797 	unsigned long lock_flags = 0;
3798 	int i;
3799 
3800 	if (!ioa_cfg->sis64) {
3801 		dev_info(&ioa_cfg->pdev->dev, "irq_poll not supported on this adapter\n");
3802 		return -EINVAL;
3803 	}
3804 	if (kstrtoul(buf, 10, &user_iopoll_weight))
3805 		return -EINVAL;
3806 
3807 	if (user_iopoll_weight > 256) {
3808 		dev_info(&ioa_cfg->pdev->dev, "Invalid irq_poll weight. It must be less than 256\n");
3809 		return -EINVAL;
3810 	}
3811 
3812 	if (user_iopoll_weight == ioa_cfg->iopoll_weight) {
3813 		dev_info(&ioa_cfg->pdev->dev, "Current irq_poll weight has the same weight\n");
3814 		return strlen(buf);
3815 	}
3816 
3817 	if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3818 		for (i = 1; i < ioa_cfg->hrrq_num; i++)
3819 			irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
3820 	}
3821 
3822 	spin_lock_irqsave(shost->host_lock, lock_flags);
3823 	ioa_cfg->iopoll_weight = user_iopoll_weight;
3824 	if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3825 		for (i = 1; i < ioa_cfg->hrrq_num; i++) {
3826 			irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
3827 					ioa_cfg->iopoll_weight, ipr_iopoll);
3828 		}
3829 	}
3830 	spin_unlock_irqrestore(shost->host_lock, lock_flags);
3831 
3832 	return strlen(buf);
3833 }
3834 
3835 static struct device_attribute ipr_iopoll_weight_attr = {
3836 	.attr = {
3837 		.name =		"iopoll_weight",
3838 		.mode =		S_IRUGO | S_IWUSR,
3839 	},
3840 	.show = ipr_show_iopoll_weight,
3841 	.store = ipr_store_iopoll_weight
3842 };
3843 
3844 /**
3845  * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3846  * @buf_len:		buffer length
3847  *
3848  * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3849  * list to use for microcode download
3850  *
3851  * Return value:
3852  * 	pointer to sglist / NULL on failure
3853  **/
3854 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3855 {
3856 	int sg_size, order;
3857 	struct ipr_sglist *sglist;
3858 
3859 	/* Get the minimum size per scatter/gather element */
3860 	sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3861 
3862 	/* Get the actual size per element */
3863 	order = get_order(sg_size);
3864 
3865 	/* Allocate a scatter/gather list for the DMA */
3866 	sglist = kzalloc(sizeof(struct ipr_sglist), GFP_KERNEL);
3867 	if (sglist == NULL) {
3868 		ipr_trace;
3869 		return NULL;
3870 	}
3871 	sglist->order = order;
3872 	sglist->scatterlist = sgl_alloc_order(buf_len, order, false, GFP_KERNEL,
3873 					      &sglist->num_sg);
3874 	if (!sglist->scatterlist) {
3875 		kfree(sglist);
3876 		return NULL;
3877 	}
3878 
3879 	return sglist;
3880 }
3881 
3882 /**
3883  * ipr_free_ucode_buffer - Frees a microcode download buffer
3884  * @sglist:		scatter/gather list pointer
3885  *
3886  * Free a DMA'able ucode download buffer previously allocated with
3887  * ipr_alloc_ucode_buffer
3888  *
3889  * Return value:
3890  * 	nothing
3891  **/
3892 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3893 {
3894 	sgl_free_order(sglist->scatterlist, sglist->order);
3895 	kfree(sglist);
3896 }
3897 
3898 /**
3899  * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3900  * @sglist:		scatter/gather list pointer
3901  * @buffer:		buffer pointer
3902  * @len:		buffer length
3903  *
3904  * Copy a microcode image from a user buffer into a buffer allocated by
3905  * ipr_alloc_ucode_buffer
3906  *
3907  * Return value:
3908  * 	0 on success / other on failure
3909  **/
3910 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3911 				 u8 *buffer, u32 len)
3912 {
3913 	int bsize_elem, i, result = 0;
3914 	struct scatterlist *sg;
3915 	void *kaddr;
3916 
3917 	/* Determine the actual number of bytes per element */
3918 	bsize_elem = PAGE_SIZE * (1 << sglist->order);
3919 
3920 	sg = sglist->scatterlist;
3921 
3922 	for (i = 0; i < (len / bsize_elem); i++, sg = sg_next(sg),
3923 			buffer += bsize_elem) {
3924 		struct page *page = sg_page(sg);
3925 
3926 		kaddr = kmap(page);
3927 		memcpy(kaddr, buffer, bsize_elem);
3928 		kunmap(page);
3929 
3930 		sg->length = bsize_elem;
3931 
3932 		if (result != 0) {
3933 			ipr_trace;
3934 			return result;
3935 		}
3936 	}
3937 
3938 	if (len % bsize_elem) {
3939 		struct page *page = sg_page(sg);
3940 
3941 		kaddr = kmap(page);
3942 		memcpy(kaddr, buffer, len % bsize_elem);
3943 		kunmap(page);
3944 
3945 		sg->length = len % bsize_elem;
3946 	}
3947 
3948 	sglist->buffer_len = len;
3949 	return result;
3950 }
3951 
3952 /**
3953  * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3954  * @ipr_cmd:		ipr command struct
3955  * @sglist:		scatter/gather list
3956  *
3957  * Builds a microcode download IOA data list (IOADL).
3958  *
3959  **/
3960 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3961 				    struct ipr_sglist *sglist)
3962 {
3963 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3964 	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3965 	struct scatterlist *scatterlist = sglist->scatterlist;
3966 	struct scatterlist *sg;
3967 	int i;
3968 
3969 	ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3970 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3971 	ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3972 
3973 	ioarcb->ioadl_len =
3974 		cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3975 	for_each_sg(scatterlist, sg, ipr_cmd->dma_use_sg, i) {
3976 		ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3977 		ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
3978 		ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
3979 	}
3980 
3981 	ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3982 }
3983 
3984 /**
3985  * ipr_build_ucode_ioadl - Build a microcode download IOADL
3986  * @ipr_cmd:	ipr command struct
3987  * @sglist:		scatter/gather list
3988  *
3989  * Builds a microcode download IOA data list (IOADL).
3990  *
3991  **/
3992 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3993 				  struct ipr_sglist *sglist)
3994 {
3995 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3996 	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3997 	struct scatterlist *scatterlist = sglist->scatterlist;
3998 	struct scatterlist *sg;
3999 	int i;
4000 
4001 	ipr_cmd->dma_use_sg = sglist->num_dma_sg;
4002 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4003 	ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
4004 
4005 	ioarcb->ioadl_len =
4006 		cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
4007 
4008 	for_each_sg(scatterlist, sg, ipr_cmd->dma_use_sg, i) {
4009 		ioadl[i].flags_and_data_len =
4010 			cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(sg));
4011 		ioadl[i].address =
4012 			cpu_to_be32(sg_dma_address(sg));
4013 	}
4014 
4015 	ioadl[i-1].flags_and_data_len |=
4016 		cpu_to_be32(IPR_IOADL_FLAGS_LAST);
4017 }
4018 
4019 /**
4020  * ipr_update_ioa_ucode - Update IOA's microcode
4021  * @ioa_cfg:	ioa config struct
4022  * @sglist:		scatter/gather list
4023  *
4024  * Initiate an adapter reset to update the IOA's microcode
4025  *
4026  * Return value:
4027  * 	0 on success / -EIO on failure
4028  **/
4029 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
4030 				struct ipr_sglist *sglist)
4031 {
4032 	unsigned long lock_flags;
4033 
4034 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4035 	while (ioa_cfg->in_reset_reload) {
4036 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4037 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4038 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4039 	}
4040 
4041 	if (ioa_cfg->ucode_sglist) {
4042 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4043 		dev_err(&ioa_cfg->pdev->dev,
4044 			"Microcode download already in progress\n");
4045 		return -EIO;
4046 	}
4047 
4048 	sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
4049 					sglist->scatterlist, sglist->num_sg,
4050 					DMA_TO_DEVICE);
4051 
4052 	if (!sglist->num_dma_sg) {
4053 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4054 		dev_err(&ioa_cfg->pdev->dev,
4055 			"Failed to map microcode download buffer!\n");
4056 		return -EIO;
4057 	}
4058 
4059 	ioa_cfg->ucode_sglist = sglist;
4060 	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
4061 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4062 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4063 
4064 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4065 	ioa_cfg->ucode_sglist = NULL;
4066 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4067 	return 0;
4068 }
4069 
4070 /**
4071  * ipr_store_update_fw - Update the firmware on the adapter
4072  * @dev:	device struct
4073  * @attr:	device attribute (unused)
4074  * @buf:	buffer
4075  * @count:	buffer size
4076  *
4077  * This function will update the firmware on the adapter.
4078  *
4079  * Return value:
4080  * 	count on success / other on failure
4081  **/
4082 static ssize_t ipr_store_update_fw(struct device *dev,
4083 				   struct device_attribute *attr,
4084 				   const char *buf, size_t count)
4085 {
4086 	struct Scsi_Host *shost = class_to_shost(dev);
4087 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4088 	struct ipr_ucode_image_header *image_hdr;
4089 	const struct firmware *fw_entry;
4090 	struct ipr_sglist *sglist;
4091 	char fname[100];
4092 	char *src;
4093 	char *endline;
4094 	int result, dnld_size;
4095 
4096 	if (!capable(CAP_SYS_ADMIN))
4097 		return -EACCES;
4098 
4099 	snprintf(fname, sizeof(fname), "%s", buf);
4100 
4101 	endline = strchr(fname, '\n');
4102 	if (endline)
4103 		*endline = '\0';
4104 
4105 	if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
4106 		dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
4107 		return -EIO;
4108 	}
4109 
4110 	image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
4111 
4112 	src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
4113 	dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
4114 	sglist = ipr_alloc_ucode_buffer(dnld_size);
4115 
4116 	if (!sglist) {
4117 		dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
4118 		release_firmware(fw_entry);
4119 		return -ENOMEM;
4120 	}
4121 
4122 	result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
4123 
4124 	if (result) {
4125 		dev_err(&ioa_cfg->pdev->dev,
4126 			"Microcode buffer copy to DMA buffer failed\n");
4127 		goto out;
4128 	}
4129 
4130 	ipr_info("Updating microcode, please be patient.  This may take up to 30 minutes.\n");
4131 
4132 	result = ipr_update_ioa_ucode(ioa_cfg, sglist);
4133 
4134 	if (!result)
4135 		result = count;
4136 out:
4137 	ipr_free_ucode_buffer(sglist);
4138 	release_firmware(fw_entry);
4139 	return result;
4140 }
4141 
4142 static struct device_attribute ipr_update_fw_attr = {
4143 	.attr = {
4144 		.name =		"update_fw",
4145 		.mode =		S_IWUSR,
4146 	},
4147 	.store = ipr_store_update_fw
4148 };
4149 
4150 /**
4151  * ipr_show_fw_type - Show the adapter's firmware type.
4152  * @dev:	class device struct
4153  * @attr:	device attribute (unused)
4154  * @buf:	buffer
4155  *
4156  * Return value:
4157  *	number of bytes printed to buffer
4158  **/
4159 static ssize_t ipr_show_fw_type(struct device *dev,
4160 				struct device_attribute *attr, char *buf)
4161 {
4162 	struct Scsi_Host *shost = class_to_shost(dev);
4163 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4164 	unsigned long lock_flags = 0;
4165 	int len;
4166 
4167 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4168 	len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
4169 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4170 	return len;
4171 }
4172 
4173 static struct device_attribute ipr_ioa_fw_type_attr = {
4174 	.attr = {
4175 		.name =		"fw_type",
4176 		.mode =		S_IRUGO,
4177 	},
4178 	.show = ipr_show_fw_type
4179 };
4180 
4181 static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj,
4182 				struct bin_attribute *bin_attr, char *buf,
4183 				loff_t off, size_t count)
4184 {
4185 	struct device *cdev = container_of(kobj, struct device, kobj);
4186 	struct Scsi_Host *shost = class_to_shost(cdev);
4187 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4188 	struct ipr_hostrcb *hostrcb;
4189 	unsigned long lock_flags = 0;
4190 	int ret;
4191 
4192 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4193 	hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4194 					struct ipr_hostrcb, queue);
4195 	if (!hostrcb) {
4196 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4197 		return 0;
4198 	}
4199 	ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam,
4200 				sizeof(hostrcb->hcam));
4201 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4202 	return ret;
4203 }
4204 
4205 static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj,
4206 				struct bin_attribute *bin_attr, char *buf,
4207 				loff_t off, size_t count)
4208 {
4209 	struct device *cdev = container_of(kobj, struct device, kobj);
4210 	struct Scsi_Host *shost = class_to_shost(cdev);
4211 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4212 	struct ipr_hostrcb *hostrcb;
4213 	unsigned long lock_flags = 0;
4214 
4215 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4216 	hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4217 					struct ipr_hostrcb, queue);
4218 	if (!hostrcb) {
4219 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4220 		return count;
4221 	}
4222 
4223 	/* Reclaim hostrcb before exit */
4224 	list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
4225 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4226 	return count;
4227 }
4228 
4229 static struct bin_attribute ipr_ioa_async_err_log = {
4230 	.attr = {
4231 		.name =		"async_err_log",
4232 		.mode =		S_IRUGO | S_IWUSR,
4233 	},
4234 	.size = 0,
4235 	.read = ipr_read_async_err_log,
4236 	.write = ipr_next_async_err_log
4237 };
4238 
4239 static struct device_attribute *ipr_ioa_attrs[] = {
4240 	&ipr_fw_version_attr,
4241 	&ipr_log_level_attr,
4242 	&ipr_diagnostics_attr,
4243 	&ipr_ioa_state_attr,
4244 	&ipr_ioa_reset_attr,
4245 	&ipr_update_fw_attr,
4246 	&ipr_ioa_fw_type_attr,
4247 	&ipr_iopoll_weight_attr,
4248 	NULL,
4249 };
4250 
4251 #ifdef CONFIG_SCSI_IPR_DUMP
4252 /**
4253  * ipr_read_dump - Dump the adapter
4254  * @filp:		open sysfs file
4255  * @kobj:		kobject struct
4256  * @bin_attr:		bin_attribute struct
4257  * @buf:		buffer
4258  * @off:		offset
4259  * @count:		buffer size
4260  *
4261  * Return value:
4262  *	number of bytes printed to buffer
4263  **/
4264 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
4265 			     struct bin_attribute *bin_attr,
4266 			     char *buf, loff_t off, size_t count)
4267 {
4268 	struct device *cdev = container_of(kobj, struct device, kobj);
4269 	struct Scsi_Host *shost = class_to_shost(cdev);
4270 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4271 	struct ipr_dump *dump;
4272 	unsigned long lock_flags = 0;
4273 	char *src;
4274 	int len, sdt_end;
4275 	size_t rc = count;
4276 
4277 	if (!capable(CAP_SYS_ADMIN))
4278 		return -EACCES;
4279 
4280 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4281 	dump = ioa_cfg->dump;
4282 
4283 	if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
4284 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4285 		return 0;
4286 	}
4287 	kref_get(&dump->kref);
4288 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4289 
4290 	if (off > dump->driver_dump.hdr.len) {
4291 		kref_put(&dump->kref, ipr_release_dump);
4292 		return 0;
4293 	}
4294 
4295 	if (off + count > dump->driver_dump.hdr.len) {
4296 		count = dump->driver_dump.hdr.len - off;
4297 		rc = count;
4298 	}
4299 
4300 	if (count && off < sizeof(dump->driver_dump)) {
4301 		if (off + count > sizeof(dump->driver_dump))
4302 			len = sizeof(dump->driver_dump) - off;
4303 		else
4304 			len = count;
4305 		src = (u8 *)&dump->driver_dump + off;
4306 		memcpy(buf, src, len);
4307 		buf += len;
4308 		off += len;
4309 		count -= len;
4310 	}
4311 
4312 	off -= sizeof(dump->driver_dump);
4313 
4314 	if (ioa_cfg->sis64)
4315 		sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4316 			  (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
4317 			   sizeof(struct ipr_sdt_entry));
4318 	else
4319 		sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4320 			  (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
4321 
4322 	if (count && off < sdt_end) {
4323 		if (off + count > sdt_end)
4324 			len = sdt_end - off;
4325 		else
4326 			len = count;
4327 		src = (u8 *)&dump->ioa_dump + off;
4328 		memcpy(buf, src, len);
4329 		buf += len;
4330 		off += len;
4331 		count -= len;
4332 	}
4333 
4334 	off -= sdt_end;
4335 
4336 	while (count) {
4337 		if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
4338 			len = PAGE_ALIGN(off) - off;
4339 		else
4340 			len = count;
4341 		src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
4342 		src += off & ~PAGE_MASK;
4343 		memcpy(buf, src, len);
4344 		buf += len;
4345 		off += len;
4346 		count -= len;
4347 	}
4348 
4349 	kref_put(&dump->kref, ipr_release_dump);
4350 	return rc;
4351 }
4352 
4353 /**
4354  * ipr_alloc_dump - Prepare for adapter dump
4355  * @ioa_cfg:	ioa config struct
4356  *
4357  * Return value:
4358  *	0 on success / other on failure
4359  **/
4360 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
4361 {
4362 	struct ipr_dump *dump;
4363 	__be32 **ioa_data;
4364 	unsigned long lock_flags = 0;
4365 
4366 	dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
4367 
4368 	if (!dump) {
4369 		ipr_err("Dump memory allocation failed\n");
4370 		return -ENOMEM;
4371 	}
4372 
4373 	if (ioa_cfg->sis64)
4374 		ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES,
4375 					      sizeof(__be32 *)));
4376 	else
4377 		ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES,
4378 					      sizeof(__be32 *)));
4379 
4380 	if (!ioa_data) {
4381 		ipr_err("Dump memory allocation failed\n");
4382 		kfree(dump);
4383 		return -ENOMEM;
4384 	}
4385 
4386 	dump->ioa_dump.ioa_data = ioa_data;
4387 
4388 	kref_init(&dump->kref);
4389 	dump->ioa_cfg = ioa_cfg;
4390 
4391 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4392 
4393 	if (INACTIVE != ioa_cfg->sdt_state) {
4394 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4395 		vfree(dump->ioa_dump.ioa_data);
4396 		kfree(dump);
4397 		return 0;
4398 	}
4399 
4400 	ioa_cfg->dump = dump;
4401 	ioa_cfg->sdt_state = WAIT_FOR_DUMP;
4402 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
4403 		ioa_cfg->dump_taken = 1;
4404 		schedule_work(&ioa_cfg->work_q);
4405 	}
4406 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4407 
4408 	return 0;
4409 }
4410 
4411 /**
4412  * ipr_free_dump - Free adapter dump memory
4413  * @ioa_cfg:	ioa config struct
4414  *
4415  * Return value:
4416  *	0 on success / other on failure
4417  **/
4418 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4419 {
4420 	struct ipr_dump *dump;
4421 	unsigned long lock_flags = 0;
4422 
4423 	ENTER;
4424 
4425 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4426 	dump = ioa_cfg->dump;
4427 	if (!dump) {
4428 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4429 		return 0;
4430 	}
4431 
4432 	ioa_cfg->dump = NULL;
4433 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4434 
4435 	kref_put(&dump->kref, ipr_release_dump);
4436 
4437 	LEAVE;
4438 	return 0;
4439 }
4440 
4441 /**
4442  * ipr_write_dump - Setup dump state of adapter
4443  * @filp:		open sysfs file
4444  * @kobj:		kobject struct
4445  * @bin_attr:		bin_attribute struct
4446  * @buf:		buffer
4447  * @off:		offset
4448  * @count:		buffer size
4449  *
4450  * Return value:
4451  *	number of bytes printed to buffer
4452  **/
4453 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4454 			      struct bin_attribute *bin_attr,
4455 			      char *buf, loff_t off, size_t count)
4456 {
4457 	struct device *cdev = container_of(kobj, struct device, kobj);
4458 	struct Scsi_Host *shost = class_to_shost(cdev);
4459 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4460 	int rc;
4461 
4462 	if (!capable(CAP_SYS_ADMIN))
4463 		return -EACCES;
4464 
4465 	if (buf[0] == '1')
4466 		rc = ipr_alloc_dump(ioa_cfg);
4467 	else if (buf[0] == '0')
4468 		rc = ipr_free_dump(ioa_cfg);
4469 	else
4470 		return -EINVAL;
4471 
4472 	if (rc)
4473 		return rc;
4474 	else
4475 		return count;
4476 }
4477 
4478 static struct bin_attribute ipr_dump_attr = {
4479 	.attr =	{
4480 		.name = "dump",
4481 		.mode = S_IRUSR | S_IWUSR,
4482 	},
4483 	.size = 0,
4484 	.read = ipr_read_dump,
4485 	.write = ipr_write_dump
4486 };
4487 #else
4488 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4489 #endif
4490 
4491 /**
4492  * ipr_change_queue_depth - Change the device's queue depth
4493  * @sdev:	scsi device struct
4494  * @qdepth:	depth to set
4495  *
4496  * Return value:
4497  * 	actual depth set
4498  **/
4499 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
4500 {
4501 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4502 	struct ipr_resource_entry *res;
4503 	unsigned long lock_flags = 0;
4504 
4505 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4506 	res = (struct ipr_resource_entry *)sdev->hostdata;
4507 
4508 	if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4509 		qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4510 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4511 
4512 	scsi_change_queue_depth(sdev, qdepth);
4513 	return sdev->queue_depth;
4514 }
4515 
4516 /**
4517  * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4518  * @dev:	device struct
4519  * @attr:	device attribute structure
4520  * @buf:	buffer
4521  *
4522  * Return value:
4523  * 	number of bytes printed to buffer
4524  **/
4525 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4526 {
4527 	struct scsi_device *sdev = to_scsi_device(dev);
4528 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4529 	struct ipr_resource_entry *res;
4530 	unsigned long lock_flags = 0;
4531 	ssize_t len = -ENXIO;
4532 
4533 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4534 	res = (struct ipr_resource_entry *)sdev->hostdata;
4535 	if (res)
4536 		len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4537 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4538 	return len;
4539 }
4540 
4541 static struct device_attribute ipr_adapter_handle_attr = {
4542 	.attr = {
4543 		.name = 	"adapter_handle",
4544 		.mode =		S_IRUSR,
4545 	},
4546 	.show = ipr_show_adapter_handle
4547 };
4548 
4549 /**
4550  * ipr_show_resource_path - Show the resource path or the resource address for
4551  *			    this device.
4552  * @dev:	device struct
4553  * @attr:	device attribute structure
4554  * @buf:	buffer
4555  *
4556  * Return value:
4557  * 	number of bytes printed to buffer
4558  **/
4559 static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4560 {
4561 	struct scsi_device *sdev = to_scsi_device(dev);
4562 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4563 	struct ipr_resource_entry *res;
4564 	unsigned long lock_flags = 0;
4565 	ssize_t len = -ENXIO;
4566 	char buffer[IPR_MAX_RES_PATH_LENGTH];
4567 
4568 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4569 	res = (struct ipr_resource_entry *)sdev->hostdata;
4570 	if (res && ioa_cfg->sis64)
4571 		len = snprintf(buf, PAGE_SIZE, "%s\n",
4572 			       __ipr_format_res_path(res->res_path, buffer,
4573 						     sizeof(buffer)));
4574 	else if (res)
4575 		len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4576 			       res->bus, res->target, res->lun);
4577 
4578 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4579 	return len;
4580 }
4581 
4582 static struct device_attribute ipr_resource_path_attr = {
4583 	.attr = {
4584 		.name = 	"resource_path",
4585 		.mode =		S_IRUGO,
4586 	},
4587 	.show = ipr_show_resource_path
4588 };
4589 
4590 /**
4591  * ipr_show_device_id - Show the device_id for this device.
4592  * @dev:	device struct
4593  * @attr:	device attribute structure
4594  * @buf:	buffer
4595  *
4596  * Return value:
4597  *	number of bytes printed to buffer
4598  **/
4599 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4600 {
4601 	struct scsi_device *sdev = to_scsi_device(dev);
4602 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4603 	struct ipr_resource_entry *res;
4604 	unsigned long lock_flags = 0;
4605 	ssize_t len = -ENXIO;
4606 
4607 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4608 	res = (struct ipr_resource_entry *)sdev->hostdata;
4609 	if (res && ioa_cfg->sis64)
4610 		len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id));
4611 	else if (res)
4612 		len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4613 
4614 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4615 	return len;
4616 }
4617 
4618 static struct device_attribute ipr_device_id_attr = {
4619 	.attr = {
4620 		.name =		"device_id",
4621 		.mode =		S_IRUGO,
4622 	},
4623 	.show = ipr_show_device_id
4624 };
4625 
4626 /**
4627  * ipr_show_resource_type - Show the resource type for this device.
4628  * @dev:	device struct
4629  * @attr:	device attribute structure
4630  * @buf:	buffer
4631  *
4632  * Return value:
4633  *	number of bytes printed to buffer
4634  **/
4635 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4636 {
4637 	struct scsi_device *sdev = to_scsi_device(dev);
4638 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4639 	struct ipr_resource_entry *res;
4640 	unsigned long lock_flags = 0;
4641 	ssize_t len = -ENXIO;
4642 
4643 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4644 	res = (struct ipr_resource_entry *)sdev->hostdata;
4645 
4646 	if (res)
4647 		len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4648 
4649 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4650 	return len;
4651 }
4652 
4653 static struct device_attribute ipr_resource_type_attr = {
4654 	.attr = {
4655 		.name =		"resource_type",
4656 		.mode =		S_IRUGO,
4657 	},
4658 	.show = ipr_show_resource_type
4659 };
4660 
4661 /**
4662  * ipr_show_raw_mode - Show the adapter's raw mode
4663  * @dev:	class device struct
4664  * @attr:	device attribute (unused)
4665  * @buf:	buffer
4666  *
4667  * Return value:
4668  * 	number of bytes printed to buffer
4669  **/
4670 static ssize_t ipr_show_raw_mode(struct device *dev,
4671 				 struct device_attribute *attr, char *buf)
4672 {
4673 	struct scsi_device *sdev = to_scsi_device(dev);
4674 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4675 	struct ipr_resource_entry *res;
4676 	unsigned long lock_flags = 0;
4677 	ssize_t len;
4678 
4679 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4680 	res = (struct ipr_resource_entry *)sdev->hostdata;
4681 	if (res)
4682 		len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode);
4683 	else
4684 		len = -ENXIO;
4685 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4686 	return len;
4687 }
4688 
4689 /**
4690  * ipr_store_raw_mode - Change the adapter's raw mode
4691  * @dev:	class device struct
4692  * @attr:	device attribute (unused)
4693  * @buf:	buffer
4694  * @count:		buffer size
4695  *
4696  * Return value:
4697  * 	number of bytes printed to buffer
4698  **/
4699 static ssize_t ipr_store_raw_mode(struct device *dev,
4700 				  struct device_attribute *attr,
4701 				  const char *buf, size_t count)
4702 {
4703 	struct scsi_device *sdev = to_scsi_device(dev);
4704 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4705 	struct ipr_resource_entry *res;
4706 	unsigned long lock_flags = 0;
4707 	ssize_t len;
4708 
4709 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4710 	res = (struct ipr_resource_entry *)sdev->hostdata;
4711 	if (res) {
4712 		if (ipr_is_af_dasd_device(res)) {
4713 			res->raw_mode = simple_strtoul(buf, NULL, 10);
4714 			len = strlen(buf);
4715 			if (res->sdev)
4716 				sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n",
4717 					res->raw_mode ? "enabled" : "disabled");
4718 		} else
4719 			len = -EINVAL;
4720 	} else
4721 		len = -ENXIO;
4722 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4723 	return len;
4724 }
4725 
4726 static struct device_attribute ipr_raw_mode_attr = {
4727 	.attr = {
4728 		.name =		"raw_mode",
4729 		.mode =		S_IRUGO | S_IWUSR,
4730 	},
4731 	.show = ipr_show_raw_mode,
4732 	.store = ipr_store_raw_mode
4733 };
4734 
4735 static struct device_attribute *ipr_dev_attrs[] = {
4736 	&ipr_adapter_handle_attr,
4737 	&ipr_resource_path_attr,
4738 	&ipr_device_id_attr,
4739 	&ipr_resource_type_attr,
4740 	&ipr_raw_mode_attr,
4741 	NULL,
4742 };
4743 
4744 /**
4745  * ipr_biosparam - Return the HSC mapping
4746  * @sdev:			scsi device struct
4747  * @block_device:	block device pointer
4748  * @capacity:		capacity of the device
4749  * @parm:			Array containing returned HSC values.
4750  *
4751  * This function generates the HSC parms that fdisk uses.
4752  * We want to make sure we return something that places partitions
4753  * on 4k boundaries for best performance with the IOA.
4754  *
4755  * Return value:
4756  * 	0 on success
4757  **/
4758 static int ipr_biosparam(struct scsi_device *sdev,
4759 			 struct block_device *block_device,
4760 			 sector_t capacity, int *parm)
4761 {
4762 	int heads, sectors;
4763 	sector_t cylinders;
4764 
4765 	heads = 128;
4766 	sectors = 32;
4767 
4768 	cylinders = capacity;
4769 	sector_div(cylinders, (128 * 32));
4770 
4771 	/* return result */
4772 	parm[0] = heads;
4773 	parm[1] = sectors;
4774 	parm[2] = cylinders;
4775 
4776 	return 0;
4777 }
4778 
4779 /**
4780  * ipr_find_starget - Find target based on bus/target.
4781  * @starget:	scsi target struct
4782  *
4783  * Return value:
4784  * 	resource entry pointer if found / NULL if not found
4785  **/
4786 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4787 {
4788 	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4789 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4790 	struct ipr_resource_entry *res;
4791 
4792 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4793 		if ((res->bus == starget->channel) &&
4794 		    (res->target == starget->id)) {
4795 			return res;
4796 		}
4797 	}
4798 
4799 	return NULL;
4800 }
4801 
4802 static struct ata_port_info sata_port_info;
4803 
4804 /**
4805  * ipr_target_alloc - Prepare for commands to a SCSI target
4806  * @starget:	scsi target struct
4807  *
4808  * If the device is a SATA device, this function allocates an
4809  * ATA port with libata, else it does nothing.
4810  *
4811  * Return value:
4812  * 	0 on success / non-0 on failure
4813  **/
4814 static int ipr_target_alloc(struct scsi_target *starget)
4815 {
4816 	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4817 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4818 	struct ipr_sata_port *sata_port;
4819 	struct ata_port *ap;
4820 	struct ipr_resource_entry *res;
4821 	unsigned long lock_flags;
4822 
4823 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4824 	res = ipr_find_starget(starget);
4825 	starget->hostdata = NULL;
4826 
4827 	if (res && ipr_is_gata(res)) {
4828 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4829 		sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4830 		if (!sata_port)
4831 			return -ENOMEM;
4832 
4833 		ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4834 		if (ap) {
4835 			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4836 			sata_port->ioa_cfg = ioa_cfg;
4837 			sata_port->ap = ap;
4838 			sata_port->res = res;
4839 
4840 			res->sata_port = sata_port;
4841 			ap->private_data = sata_port;
4842 			starget->hostdata = sata_port;
4843 		} else {
4844 			kfree(sata_port);
4845 			return -ENOMEM;
4846 		}
4847 	}
4848 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4849 
4850 	return 0;
4851 }
4852 
4853 /**
4854  * ipr_target_destroy - Destroy a SCSI target
4855  * @starget:	scsi target struct
4856  *
4857  * If the device was a SATA device, this function frees the libata
4858  * ATA port, else it does nothing.
4859  *
4860  **/
4861 static void ipr_target_destroy(struct scsi_target *starget)
4862 {
4863 	struct ipr_sata_port *sata_port = starget->hostdata;
4864 	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4865 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4866 
4867 	if (ioa_cfg->sis64) {
4868 		if (!ipr_find_starget(starget)) {
4869 			if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4870 				clear_bit(starget->id, ioa_cfg->array_ids);
4871 			else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4872 				clear_bit(starget->id, ioa_cfg->vset_ids);
4873 			else if (starget->channel == 0)
4874 				clear_bit(starget->id, ioa_cfg->target_ids);
4875 		}
4876 	}
4877 
4878 	if (sata_port) {
4879 		starget->hostdata = NULL;
4880 		ata_sas_port_destroy(sata_port->ap);
4881 		kfree(sata_port);
4882 	}
4883 }
4884 
4885 /**
4886  * ipr_find_sdev - Find device based on bus/target/lun.
4887  * @sdev:	scsi device struct
4888  *
4889  * Return value:
4890  * 	resource entry pointer if found / NULL if not found
4891  **/
4892 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4893 {
4894 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4895 	struct ipr_resource_entry *res;
4896 
4897 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4898 		if ((res->bus == sdev->channel) &&
4899 		    (res->target == sdev->id) &&
4900 		    (res->lun == sdev->lun))
4901 			return res;
4902 	}
4903 
4904 	return NULL;
4905 }
4906 
4907 /**
4908  * ipr_slave_destroy - Unconfigure a SCSI device
4909  * @sdev:	scsi device struct
4910  *
4911  * Return value:
4912  * 	nothing
4913  **/
4914 static void ipr_slave_destroy(struct scsi_device *sdev)
4915 {
4916 	struct ipr_resource_entry *res;
4917 	struct ipr_ioa_cfg *ioa_cfg;
4918 	unsigned long lock_flags = 0;
4919 
4920 	ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4921 
4922 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4923 	res = (struct ipr_resource_entry *) sdev->hostdata;
4924 	if (res) {
4925 		if (res->sata_port)
4926 			res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4927 		sdev->hostdata = NULL;
4928 		res->sdev = NULL;
4929 		res->sata_port = NULL;
4930 	}
4931 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4932 }
4933 
4934 /**
4935  * ipr_slave_configure - Configure a SCSI device
4936  * @sdev:	scsi device struct
4937  *
4938  * This function configures the specified scsi device.
4939  *
4940  * Return value:
4941  * 	0 on success
4942  **/
4943 static int ipr_slave_configure(struct scsi_device *sdev)
4944 {
4945 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4946 	struct ipr_resource_entry *res;
4947 	struct ata_port *ap = NULL;
4948 	unsigned long lock_flags = 0;
4949 	char buffer[IPR_MAX_RES_PATH_LENGTH];
4950 
4951 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4952 	res = sdev->hostdata;
4953 	if (res) {
4954 		if (ipr_is_af_dasd_device(res))
4955 			sdev->type = TYPE_RAID;
4956 		if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4957 			sdev->scsi_level = 4;
4958 			sdev->no_uld_attach = 1;
4959 		}
4960 		if (ipr_is_vset_device(res)) {
4961 			sdev->scsi_level = SCSI_SPC_3;
4962 			sdev->no_report_opcodes = 1;
4963 			blk_queue_rq_timeout(sdev->request_queue,
4964 					     IPR_VSET_RW_TIMEOUT);
4965 			blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4966 		}
4967 		if (ipr_is_gata(res) && res->sata_port)
4968 			ap = res->sata_port->ap;
4969 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4970 
4971 		if (ap) {
4972 			scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
4973 			ata_sas_slave_configure(sdev, ap);
4974 		}
4975 
4976 		if (ioa_cfg->sis64)
4977 			sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4978 				    ipr_format_res_path(ioa_cfg,
4979 				res->res_path, buffer, sizeof(buffer)));
4980 		return 0;
4981 	}
4982 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4983 	return 0;
4984 }
4985 
4986 /**
4987  * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4988  * @sdev:	scsi device struct
4989  *
4990  * This function initializes an ATA port so that future commands
4991  * sent through queuecommand will work.
4992  *
4993  * Return value:
4994  * 	0 on success
4995  **/
4996 static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4997 {
4998 	struct ipr_sata_port *sata_port = NULL;
4999 	int rc = -ENXIO;
5000 
5001 	ENTER;
5002 	if (sdev->sdev_target)
5003 		sata_port = sdev->sdev_target->hostdata;
5004 	if (sata_port) {
5005 		rc = ata_sas_port_init(sata_port->ap);
5006 		if (rc == 0)
5007 			rc = ata_sas_sync_probe(sata_port->ap);
5008 	}
5009 
5010 	if (rc)
5011 		ipr_slave_destroy(sdev);
5012 
5013 	LEAVE;
5014 	return rc;
5015 }
5016 
5017 /**
5018  * ipr_slave_alloc - Prepare for commands to a device.
5019  * @sdev:	scsi device struct
5020  *
5021  * This function saves a pointer to the resource entry
5022  * in the scsi device struct if the device exists. We
5023  * can then use this pointer in ipr_queuecommand when
5024  * handling new commands.
5025  *
5026  * Return value:
5027  * 	0 on success / -ENXIO if device does not exist
5028  **/
5029 static int ipr_slave_alloc(struct scsi_device *sdev)
5030 {
5031 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
5032 	struct ipr_resource_entry *res;
5033 	unsigned long lock_flags;
5034 	int rc = -ENXIO;
5035 
5036 	sdev->hostdata = NULL;
5037 
5038 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5039 
5040 	res = ipr_find_sdev(sdev);
5041 	if (res) {
5042 		res->sdev = sdev;
5043 		res->add_to_ml = 0;
5044 		res->in_erp = 0;
5045 		sdev->hostdata = res;
5046 		if (!ipr_is_naca_model(res))
5047 			res->needs_sync_complete = 1;
5048 		rc = 0;
5049 		if (ipr_is_gata(res)) {
5050 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5051 			return ipr_ata_slave_alloc(sdev);
5052 		}
5053 	}
5054 
5055 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5056 
5057 	return rc;
5058 }
5059 
5060 /**
5061  * ipr_match_lun - Match function for specified LUN
5062  * @ipr_cmd:	ipr command struct
5063  * @device:		device to match (sdev)
5064  *
5065  * Returns:
5066  *	1 if command matches sdev / 0 if command does not match sdev
5067  **/
5068 static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device)
5069 {
5070 	if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device)
5071 		return 1;
5072 	return 0;
5073 }
5074 
5075 /**
5076  * ipr_cmnd_is_free - Check if a command is free or not
5077  * @ipr_cmd:	ipr command struct
5078  *
5079  * Returns:
5080  *	true / false
5081  **/
5082 static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd)
5083 {
5084 	struct ipr_cmnd *loop_cmd;
5085 
5086 	list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) {
5087 		if (loop_cmd == ipr_cmd)
5088 			return true;
5089 	}
5090 
5091 	return false;
5092 }
5093 
5094 /**
5095  * ipr_match_res - Match function for specified resource entry
5096  * @ipr_cmd:	ipr command struct
5097  * @resource:	resource entry to match
5098  *
5099  * Returns:
5100  *	1 if command matches sdev / 0 if command does not match sdev
5101  **/
5102 static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource)
5103 {
5104 	struct ipr_resource_entry *res = resource;
5105 
5106 	if (res && ipr_cmd->ioarcb.res_handle == res->res_handle)
5107 		return 1;
5108 	return 0;
5109 }
5110 
5111 /**
5112  * ipr_wait_for_ops - Wait for matching commands to complete
5113  * @ioa_cfg:	ioa config struct
5114  * @device:		device to match (sdev)
5115  * @match:		match function to use
5116  *
5117  * Returns:
5118  *	SUCCESS / FAILED
5119  **/
5120 static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device,
5121 			    int (*match)(struct ipr_cmnd *, void *))
5122 {
5123 	struct ipr_cmnd *ipr_cmd;
5124 	int wait, i;
5125 	unsigned long flags;
5126 	struct ipr_hrr_queue *hrrq;
5127 	signed long timeout = IPR_ABORT_TASK_TIMEOUT;
5128 	DECLARE_COMPLETION_ONSTACK(comp);
5129 
5130 	ENTER;
5131 	do {
5132 		wait = 0;
5133 
5134 		for_each_hrrq(hrrq, ioa_cfg) {
5135 			spin_lock_irqsave(hrrq->lock, flags);
5136 			for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5137 				ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5138 				if (!ipr_cmnd_is_free(ipr_cmd)) {
5139 					if (match(ipr_cmd, device)) {
5140 						ipr_cmd->eh_comp = &comp;
5141 						wait++;
5142 					}
5143 				}
5144 			}
5145 			spin_unlock_irqrestore(hrrq->lock, flags);
5146 		}
5147 
5148 		if (wait) {
5149 			timeout = wait_for_completion_timeout(&comp, timeout);
5150 
5151 			if (!timeout) {
5152 				wait = 0;
5153 
5154 				for_each_hrrq(hrrq, ioa_cfg) {
5155 					spin_lock_irqsave(hrrq->lock, flags);
5156 					for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5157 						ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5158 						if (!ipr_cmnd_is_free(ipr_cmd)) {
5159 							if (match(ipr_cmd, device)) {
5160 								ipr_cmd->eh_comp = NULL;
5161 								wait++;
5162 							}
5163 						}
5164 					}
5165 					spin_unlock_irqrestore(hrrq->lock, flags);
5166 				}
5167 
5168 				if (wait)
5169 					dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n");
5170 				LEAVE;
5171 				return wait ? FAILED : SUCCESS;
5172 			}
5173 		}
5174 	} while (wait);
5175 
5176 	LEAVE;
5177 	return SUCCESS;
5178 }
5179 
5180 static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
5181 {
5182 	struct ipr_ioa_cfg *ioa_cfg;
5183 	unsigned long lock_flags = 0;
5184 	int rc = SUCCESS;
5185 
5186 	ENTER;
5187 	ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5188 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5189 
5190 	if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5191 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5192 		dev_err(&ioa_cfg->pdev->dev,
5193 			"Adapter being reset as a result of error recovery.\n");
5194 
5195 		if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5196 			ioa_cfg->sdt_state = GET_DUMP;
5197 	}
5198 
5199 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5200 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5201 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5202 
5203 	/* If we got hit with a host reset while we were already resetting
5204 	 the adapter for some reason, and the reset failed. */
5205 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5206 		ipr_trace;
5207 		rc = FAILED;
5208 	}
5209 
5210 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5211 	LEAVE;
5212 	return rc;
5213 }
5214 
5215 /**
5216  * ipr_device_reset - Reset the device
5217  * @ioa_cfg:	ioa config struct
5218  * @res:		resource entry struct
5219  *
5220  * This function issues a device reset to the affected device.
5221  * If the device is a SCSI device, a LUN reset will be sent
5222  * to the device first. If that does not work, a target reset
5223  * will be sent. If the device is a SATA device, a PHY reset will
5224  * be sent.
5225  *
5226  * Return value:
5227  *	0 on success / non-zero on failure
5228  **/
5229 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
5230 			    struct ipr_resource_entry *res)
5231 {
5232 	struct ipr_cmnd *ipr_cmd;
5233 	struct ipr_ioarcb *ioarcb;
5234 	struct ipr_cmd_pkt *cmd_pkt;
5235 	struct ipr_ioarcb_ata_regs *regs;
5236 	u32 ioasc;
5237 
5238 	ENTER;
5239 	ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5240 	ioarcb = &ipr_cmd->ioarcb;
5241 	cmd_pkt = &ioarcb->cmd_pkt;
5242 
5243 	if (ipr_cmd->ioa_cfg->sis64) {
5244 		regs = &ipr_cmd->i.ata_ioadl.regs;
5245 		ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
5246 	} else
5247 		regs = &ioarcb->u.add_data.u.regs;
5248 
5249 	ioarcb->res_handle = res->res_handle;
5250 	cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5251 	cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5252 	if (ipr_is_gata(res)) {
5253 		cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
5254 		ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
5255 		regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
5256 	}
5257 
5258 	ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5259 	ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5260 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5261 	if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
5262 		if (ipr_cmd->ioa_cfg->sis64)
5263 			memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
5264 			       sizeof(struct ipr_ioasa_gata));
5265 		else
5266 			memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
5267 			       sizeof(struct ipr_ioasa_gata));
5268 	}
5269 
5270 	LEAVE;
5271 	return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
5272 }
5273 
5274 /**
5275  * ipr_sata_reset - Reset the SATA port
5276  * @link:	SATA link to reset
5277  * @classes:	class of the attached device
5278  * @deadline:	unused
5279  *
5280  * This function issues a SATA phy reset to the affected ATA link.
5281  *
5282  * Return value:
5283  *	0 on success / non-zero on failure
5284  **/
5285 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
5286 				unsigned long deadline)
5287 {
5288 	struct ipr_sata_port *sata_port = link->ap->private_data;
5289 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
5290 	struct ipr_resource_entry *res;
5291 	unsigned long lock_flags = 0;
5292 	int rc = -ENXIO, ret;
5293 
5294 	ENTER;
5295 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5296 	while (ioa_cfg->in_reset_reload) {
5297 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5298 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5299 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5300 	}
5301 
5302 	res = sata_port->res;
5303 	if (res) {
5304 		rc = ipr_device_reset(ioa_cfg, res);
5305 		*classes = res->ata_class;
5306 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5307 
5308 		ret = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5309 		if (ret != SUCCESS) {
5310 			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5311 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5312 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5313 
5314 			wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5315 		}
5316 	} else
5317 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5318 
5319 	LEAVE;
5320 	return rc;
5321 }
5322 
5323 /**
5324  * __ipr_eh_dev_reset - Reset the device
5325  * @scsi_cmd:	scsi command struct
5326  *
5327  * This function issues a device reset to the affected device.
5328  * A LUN reset will be sent to the device first. If that does
5329  * not work, a target reset will be sent.
5330  *
5331  * Return value:
5332  *	SUCCESS / FAILED
5333  **/
5334 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
5335 {
5336 	struct ipr_cmnd *ipr_cmd;
5337 	struct ipr_ioa_cfg *ioa_cfg;
5338 	struct ipr_resource_entry *res;
5339 	struct ata_port *ap;
5340 	int rc = 0, i;
5341 	struct ipr_hrr_queue *hrrq;
5342 
5343 	ENTER;
5344 	ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5345 	res = scsi_cmd->device->hostdata;
5346 
5347 	/*
5348 	 * If we are currently going through reset/reload, return failed. This will force the
5349 	 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
5350 	 * reset to complete
5351 	 */
5352 	if (ioa_cfg->in_reset_reload)
5353 		return FAILED;
5354 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5355 		return FAILED;
5356 
5357 	for_each_hrrq(hrrq, ioa_cfg) {
5358 		spin_lock(&hrrq->_lock);
5359 		for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5360 			ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5361 
5362 			if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
5363 				if (!ipr_cmd->qc)
5364 					continue;
5365 				if (ipr_cmnd_is_free(ipr_cmd))
5366 					continue;
5367 
5368 				ipr_cmd->done = ipr_sata_eh_done;
5369 				if (!(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
5370 					ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
5371 					ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
5372 				}
5373 			}
5374 		}
5375 		spin_unlock(&hrrq->_lock);
5376 	}
5377 	res->resetting_device = 1;
5378 	scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
5379 
5380 	if (ipr_is_gata(res) && res->sata_port) {
5381 		ap = res->sata_port->ap;
5382 		spin_unlock_irq(scsi_cmd->device->host->host_lock);
5383 		ata_std_error_handler(ap);
5384 		spin_lock_irq(scsi_cmd->device->host->host_lock);
5385 	} else
5386 		rc = ipr_device_reset(ioa_cfg, res);
5387 	res->resetting_device = 0;
5388 	res->reset_occurred = 1;
5389 
5390 	LEAVE;
5391 	return rc ? FAILED : SUCCESS;
5392 }
5393 
5394 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
5395 {
5396 	int rc;
5397 	struct ipr_ioa_cfg *ioa_cfg;
5398 	struct ipr_resource_entry *res;
5399 
5400 	ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5401 	res = cmd->device->hostdata;
5402 
5403 	if (!res)
5404 		return FAILED;
5405 
5406 	spin_lock_irq(cmd->device->host->host_lock);
5407 	rc = __ipr_eh_dev_reset(cmd);
5408 	spin_unlock_irq(cmd->device->host->host_lock);
5409 
5410 	if (rc == SUCCESS) {
5411 		if (ipr_is_gata(res) && res->sata_port)
5412 			rc = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5413 		else
5414 			rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun);
5415 	}
5416 
5417 	return rc;
5418 }
5419 
5420 /**
5421  * ipr_bus_reset_done - Op done function for bus reset.
5422  * @ipr_cmd:	ipr command struct
5423  *
5424  * This function is the op done function for a bus reset
5425  *
5426  * Return value:
5427  * 	none
5428  **/
5429 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
5430 {
5431 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5432 	struct ipr_resource_entry *res;
5433 
5434 	ENTER;
5435 	if (!ioa_cfg->sis64)
5436 		list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
5437 			if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
5438 				scsi_report_bus_reset(ioa_cfg->host, res->bus);
5439 				break;
5440 			}
5441 		}
5442 
5443 	/*
5444 	 * If abort has not completed, indicate the reset has, else call the
5445 	 * abort's done function to wake the sleeping eh thread
5446 	 */
5447 	if (ipr_cmd->sibling->sibling)
5448 		ipr_cmd->sibling->sibling = NULL;
5449 	else
5450 		ipr_cmd->sibling->done(ipr_cmd->sibling);
5451 
5452 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5453 	LEAVE;
5454 }
5455 
5456 /**
5457  * ipr_abort_timeout - An abort task has timed out
5458  * @t: Timer context used to fetch ipr command struct
5459  *
5460  * This function handles when an abort task times out. If this
5461  * happens we issue a bus reset since we have resources tied
5462  * up that must be freed before returning to the midlayer.
5463  *
5464  * Return value:
5465  *	none
5466  **/
5467 static void ipr_abort_timeout(struct timer_list *t)
5468 {
5469 	struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
5470 	struct ipr_cmnd *reset_cmd;
5471 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5472 	struct ipr_cmd_pkt *cmd_pkt;
5473 	unsigned long lock_flags = 0;
5474 
5475 	ENTER;
5476 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5477 	if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
5478 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5479 		return;
5480 	}
5481 
5482 	sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
5483 	reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5484 	ipr_cmd->sibling = reset_cmd;
5485 	reset_cmd->sibling = ipr_cmd;
5486 	reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
5487 	cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
5488 	cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5489 	cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5490 	cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
5491 
5492 	ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5493 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5494 	LEAVE;
5495 }
5496 
5497 /**
5498  * ipr_cancel_op - Cancel specified op
5499  * @scsi_cmd:	scsi command struct
5500  *
5501  * This function cancels specified op.
5502  *
5503  * Return value:
5504  *	SUCCESS / FAILED
5505  **/
5506 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
5507 {
5508 	struct ipr_cmnd *ipr_cmd;
5509 	struct ipr_ioa_cfg *ioa_cfg;
5510 	struct ipr_resource_entry *res;
5511 	struct ipr_cmd_pkt *cmd_pkt;
5512 	u32 ioasc;
5513 	int i, op_found = 0;
5514 	struct ipr_hrr_queue *hrrq;
5515 
5516 	ENTER;
5517 	ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5518 	res = scsi_cmd->device->hostdata;
5519 
5520 	/* If we are currently going through reset/reload, return failed.
5521 	 * This will force the mid-layer to call ipr_eh_host_reset,
5522 	 * which will then go to sleep and wait for the reset to complete
5523 	 */
5524 	if (ioa_cfg->in_reset_reload ||
5525 	    ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5526 		return FAILED;
5527 	if (!res)
5528 		return FAILED;
5529 
5530 	/*
5531 	 * If we are aborting a timed out op, chances are that the timeout was caused
5532 	 * by a still not detected EEH error. In such cases, reading a register will
5533 	 * trigger the EEH recovery infrastructure.
5534 	 */
5535 	readl(ioa_cfg->regs.sense_interrupt_reg);
5536 
5537 	if (!ipr_is_gscsi(res))
5538 		return FAILED;
5539 
5540 	for_each_hrrq(hrrq, ioa_cfg) {
5541 		spin_lock(&hrrq->_lock);
5542 		for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5543 			if (ioa_cfg->ipr_cmnd_list[i]->scsi_cmd == scsi_cmd) {
5544 				if (!ipr_cmnd_is_free(ioa_cfg->ipr_cmnd_list[i])) {
5545 					op_found = 1;
5546 					break;
5547 				}
5548 			}
5549 		}
5550 		spin_unlock(&hrrq->_lock);
5551 	}
5552 
5553 	if (!op_found)
5554 		return SUCCESS;
5555 
5556 	ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5557 	ipr_cmd->ioarcb.res_handle = res->res_handle;
5558 	cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5559 	cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5560 	cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
5561 	ipr_cmd->u.sdev = scsi_cmd->device;
5562 
5563 	scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
5564 		    scsi_cmd->cmnd[0]);
5565 	ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
5566 	ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5567 
5568 	/*
5569 	 * If the abort task timed out and we sent a bus reset, we will get
5570 	 * one the following responses to the abort
5571 	 */
5572 	if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
5573 		ioasc = 0;
5574 		ipr_trace;
5575 	}
5576 
5577 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5578 	if (!ipr_is_naca_model(res))
5579 		res->needs_sync_complete = 1;
5580 
5581 	LEAVE;
5582 	return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
5583 }
5584 
5585 /**
5586  * ipr_scan_finished - Report whether scan is done
5587  * @shost:           scsi host struct
5588  * @elapsed_time:    elapsed time
5589  *
5590  * Return value:
5591  *	0 if scan in progress / 1 if scan is complete
5592  **/
5593 static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time)
5594 {
5595 	unsigned long lock_flags;
5596 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
5597 	int rc = 0;
5598 
5599 	spin_lock_irqsave(shost->host_lock, lock_flags);
5600 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done)
5601 		rc = 1;
5602 	if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2))
5603 		rc = 1;
5604 	spin_unlock_irqrestore(shost->host_lock, lock_flags);
5605 	return rc;
5606 }
5607 
5608 /**
5609  * ipr_eh_abort - Reset the host adapter
5610  * @scsi_cmd:	scsi command struct
5611  *
5612  * Return value:
5613  * 	SUCCESS / FAILED
5614  **/
5615 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
5616 {
5617 	unsigned long flags;
5618 	int rc;
5619 	struct ipr_ioa_cfg *ioa_cfg;
5620 
5621 	ENTER;
5622 
5623 	ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5624 
5625 	spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
5626 	rc = ipr_cancel_op(scsi_cmd);
5627 	spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
5628 
5629 	if (rc == SUCCESS)
5630 		rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun);
5631 	LEAVE;
5632 	return rc;
5633 }
5634 
5635 /**
5636  * ipr_handle_other_interrupt - Handle "other" interrupts
5637  * @ioa_cfg:	ioa config struct
5638  * @int_reg:	interrupt register
5639  *
5640  * Return value:
5641  * 	IRQ_NONE / IRQ_HANDLED
5642  **/
5643 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5644 					      u32 int_reg)
5645 {
5646 	irqreturn_t rc = IRQ_HANDLED;
5647 	u32 int_mask_reg;
5648 
5649 	int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5650 	int_reg &= ~int_mask_reg;
5651 
5652 	/* If an interrupt on the adapter did not occur, ignore it.
5653 	 * Or in the case of SIS 64, check for a stage change interrupt.
5654 	 */
5655 	if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
5656 		if (ioa_cfg->sis64) {
5657 			int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5658 			int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5659 			if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
5660 
5661 				/* clear stage change */
5662 				writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
5663 				int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5664 				list_del(&ioa_cfg->reset_cmd->queue);
5665 				del_timer(&ioa_cfg->reset_cmd->timer);
5666 				ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5667 				return IRQ_HANDLED;
5668 			}
5669 		}
5670 
5671 		return IRQ_NONE;
5672 	}
5673 
5674 	if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5675 		/* Mask the interrupt */
5676 		writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
5677 		int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5678 
5679 		list_del(&ioa_cfg->reset_cmd->queue);
5680 		del_timer(&ioa_cfg->reset_cmd->timer);
5681 		ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5682 	} else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
5683 		if (ioa_cfg->clear_isr) {
5684 			if (ipr_debug && printk_ratelimit())
5685 				dev_err(&ioa_cfg->pdev->dev,
5686 					"Spurious interrupt detected. 0x%08X\n", int_reg);
5687 			writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
5688 			int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5689 			return IRQ_NONE;
5690 		}
5691 	} else {
5692 		if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
5693 			ioa_cfg->ioa_unit_checked = 1;
5694 		else if (int_reg & IPR_PCII_NO_HOST_RRQ)
5695 			dev_err(&ioa_cfg->pdev->dev,
5696 				"No Host RRQ. 0x%08X\n", int_reg);
5697 		else
5698 			dev_err(&ioa_cfg->pdev->dev,
5699 				"Permanent IOA failure. 0x%08X\n", int_reg);
5700 
5701 		if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5702 			ioa_cfg->sdt_state = GET_DUMP;
5703 
5704 		ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5705 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5706 	}
5707 
5708 	return rc;
5709 }
5710 
5711 /**
5712  * ipr_isr_eh - Interrupt service routine error handler
5713  * @ioa_cfg:	ioa config struct
5714  * @msg:	message to log
5715  * @number:	various meanings depending on the caller/message
5716  *
5717  * Return value:
5718  * 	none
5719  **/
5720 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number)
5721 {
5722 	ioa_cfg->errors_logged++;
5723 	dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number);
5724 
5725 	if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5726 		ioa_cfg->sdt_state = GET_DUMP;
5727 
5728 	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5729 }
5730 
5731 static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget,
5732 						struct list_head *doneq)
5733 {
5734 	u32 ioasc;
5735 	u16 cmd_index;
5736 	struct ipr_cmnd *ipr_cmd;
5737 	struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg;
5738 	int num_hrrq = 0;
5739 
5740 	/* If interrupts are disabled, ignore the interrupt */
5741 	if (!hrr_queue->allow_interrupts)
5742 		return 0;
5743 
5744 	while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5745 	       hrr_queue->toggle_bit) {
5746 
5747 		cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) &
5748 			     IPR_HRRQ_REQ_RESP_HANDLE_MASK) >>
5749 			     IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
5750 
5751 		if (unlikely(cmd_index > hrr_queue->max_cmd_id ||
5752 			     cmd_index < hrr_queue->min_cmd_id)) {
5753 			ipr_isr_eh(ioa_cfg,
5754 				"Invalid response handle from IOA: ",
5755 				cmd_index);
5756 			break;
5757 		}
5758 
5759 		ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
5760 		ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5761 
5762 		ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
5763 
5764 		list_move_tail(&ipr_cmd->queue, doneq);
5765 
5766 		if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) {
5767 			hrr_queue->hrrq_curr++;
5768 		} else {
5769 			hrr_queue->hrrq_curr = hrr_queue->hrrq_start;
5770 			hrr_queue->toggle_bit ^= 1u;
5771 		}
5772 		num_hrrq++;
5773 		if (budget > 0 && num_hrrq >= budget)
5774 			break;
5775 	}
5776 
5777 	return num_hrrq;
5778 }
5779 
5780 static int ipr_iopoll(struct irq_poll *iop, int budget)
5781 {
5782 	struct ipr_hrr_queue *hrrq;
5783 	struct ipr_cmnd *ipr_cmd, *temp;
5784 	unsigned long hrrq_flags;
5785 	int completed_ops;
5786 	LIST_HEAD(doneq);
5787 
5788 	hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
5789 
5790 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
5791 	completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
5792 
5793 	if (completed_ops < budget)
5794 		irq_poll_complete(iop);
5795 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5796 
5797 	list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5798 		list_del(&ipr_cmd->queue);
5799 		del_timer(&ipr_cmd->timer);
5800 		ipr_cmd->fast_done(ipr_cmd);
5801 	}
5802 
5803 	return completed_ops;
5804 }
5805 
5806 /**
5807  * ipr_isr - Interrupt service routine
5808  * @irq:	irq number
5809  * @devp:	pointer to ioa config struct
5810  *
5811  * Return value:
5812  * 	IRQ_NONE / IRQ_HANDLED
5813  **/
5814 static irqreturn_t ipr_isr(int irq, void *devp)
5815 {
5816 	struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5817 	struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5818 	unsigned long hrrq_flags = 0;
5819 	u32 int_reg = 0;
5820 	int num_hrrq = 0;
5821 	int irq_none = 0;
5822 	struct ipr_cmnd *ipr_cmd, *temp;
5823 	irqreturn_t rc = IRQ_NONE;
5824 	LIST_HEAD(doneq);
5825 
5826 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
5827 	/* If interrupts are disabled, ignore the interrupt */
5828 	if (!hrrq->allow_interrupts) {
5829 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5830 		return IRQ_NONE;
5831 	}
5832 
5833 	while (1) {
5834 		if (ipr_process_hrrq(hrrq, -1, &doneq)) {
5835 			rc =  IRQ_HANDLED;
5836 
5837 			if (!ioa_cfg->clear_isr)
5838 				break;
5839 
5840 			/* Clear the PCI interrupt */
5841 			num_hrrq = 0;
5842 			do {
5843 				writel(IPR_PCII_HRRQ_UPDATED,
5844 				     ioa_cfg->regs.clr_interrupt_reg32);
5845 				int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5846 			} while (int_reg & IPR_PCII_HRRQ_UPDATED &&
5847 				num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
5848 
5849 		} else if (rc == IRQ_NONE && irq_none == 0) {
5850 			int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5851 			irq_none++;
5852 		} else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
5853 			   int_reg & IPR_PCII_HRRQ_UPDATED) {
5854 			ipr_isr_eh(ioa_cfg,
5855 				"Error clearing HRRQ: ", num_hrrq);
5856 			rc = IRQ_HANDLED;
5857 			break;
5858 		} else
5859 			break;
5860 	}
5861 
5862 	if (unlikely(rc == IRQ_NONE))
5863 		rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
5864 
5865 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5866 	list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5867 		list_del(&ipr_cmd->queue);
5868 		del_timer(&ipr_cmd->timer);
5869 		ipr_cmd->fast_done(ipr_cmd);
5870 	}
5871 	return rc;
5872 }
5873 
5874 /**
5875  * ipr_isr_mhrrq - Interrupt service routine
5876  * @irq:	irq number
5877  * @devp:	pointer to ioa config struct
5878  *
5879  * Return value:
5880  *	IRQ_NONE / IRQ_HANDLED
5881  **/
5882 static irqreturn_t ipr_isr_mhrrq(int irq, void *devp)
5883 {
5884 	struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5885 	struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5886 	unsigned long hrrq_flags = 0;
5887 	struct ipr_cmnd *ipr_cmd, *temp;
5888 	irqreturn_t rc = IRQ_NONE;
5889 	LIST_HEAD(doneq);
5890 
5891 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
5892 
5893 	/* If interrupts are disabled, ignore the interrupt */
5894 	if (!hrrq->allow_interrupts) {
5895 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5896 		return IRQ_NONE;
5897 	}
5898 
5899 	if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
5900 		if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5901 		       hrrq->toggle_bit) {
5902 			irq_poll_sched(&hrrq->iopoll);
5903 			spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5904 			return IRQ_HANDLED;
5905 		}
5906 	} else {
5907 		if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5908 			hrrq->toggle_bit)
5909 
5910 			if (ipr_process_hrrq(hrrq, -1, &doneq))
5911 				rc =  IRQ_HANDLED;
5912 	}
5913 
5914 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5915 
5916 	list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5917 		list_del(&ipr_cmd->queue);
5918 		del_timer(&ipr_cmd->timer);
5919 		ipr_cmd->fast_done(ipr_cmd);
5920 	}
5921 	return rc;
5922 }
5923 
5924 /**
5925  * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5926  * @ioa_cfg:	ioa config struct
5927  * @ipr_cmd:	ipr command struct
5928  *
5929  * Return value:
5930  * 	0 on success / -1 on failure
5931  **/
5932 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
5933 			     struct ipr_cmnd *ipr_cmd)
5934 {
5935 	int i, nseg;
5936 	struct scatterlist *sg;
5937 	u32 length;
5938 	u32 ioadl_flags = 0;
5939 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5940 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5941 	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
5942 
5943 	length = scsi_bufflen(scsi_cmd);
5944 	if (!length)
5945 		return 0;
5946 
5947 	nseg = scsi_dma_map(scsi_cmd);
5948 	if (nseg < 0) {
5949 		if (printk_ratelimit())
5950 			dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5951 		return -1;
5952 	}
5953 
5954 	ipr_cmd->dma_use_sg = nseg;
5955 
5956 	ioarcb->data_transfer_length = cpu_to_be32(length);
5957 	ioarcb->ioadl_len =
5958 		cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
5959 
5960 	if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5961 		ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5962 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5963 	} else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
5964 		ioadl_flags = IPR_IOADL_FLAGS_READ;
5965 
5966 	scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
5967 		ioadl64[i].flags = cpu_to_be32(ioadl_flags);
5968 		ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
5969 		ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
5970 	}
5971 
5972 	ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5973 	return 0;
5974 }
5975 
5976 /**
5977  * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5978  * @ioa_cfg:	ioa config struct
5979  * @ipr_cmd:	ipr command struct
5980  *
5981  * Return value:
5982  * 	0 on success / -1 on failure
5983  **/
5984 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
5985 			   struct ipr_cmnd *ipr_cmd)
5986 {
5987 	int i, nseg;
5988 	struct scatterlist *sg;
5989 	u32 length;
5990 	u32 ioadl_flags = 0;
5991 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5992 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5993 	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
5994 
5995 	length = scsi_bufflen(scsi_cmd);
5996 	if (!length)
5997 		return 0;
5998 
5999 	nseg = scsi_dma_map(scsi_cmd);
6000 	if (nseg < 0) {
6001 		dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
6002 		return -1;
6003 	}
6004 
6005 	ipr_cmd->dma_use_sg = nseg;
6006 
6007 	if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
6008 		ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6009 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6010 		ioarcb->data_transfer_length = cpu_to_be32(length);
6011 		ioarcb->ioadl_len =
6012 			cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6013 	} else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
6014 		ioadl_flags = IPR_IOADL_FLAGS_READ;
6015 		ioarcb->read_data_transfer_length = cpu_to_be32(length);
6016 		ioarcb->read_ioadl_len =
6017 			cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6018 	}
6019 
6020 	if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
6021 		ioadl = ioarcb->u.add_data.u.ioadl;
6022 		ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
6023 				    offsetof(struct ipr_ioarcb, u.add_data));
6024 		ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6025 	}
6026 
6027 	scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
6028 		ioadl[i].flags_and_data_len =
6029 			cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6030 		ioadl[i].address = cpu_to_be32(sg_dma_address(sg));
6031 	}
6032 
6033 	ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6034 	return 0;
6035 }
6036 
6037 /**
6038  * __ipr_erp_done - Process completion of ERP for a device
6039  * @ipr_cmd:		ipr command struct
6040  *
6041  * This function copies the sense buffer into the scsi_cmd
6042  * struct and pushes the scsi_done function.
6043  *
6044  * Return value:
6045  * 	nothing
6046  **/
6047 static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6048 {
6049 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6050 	struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6051 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6052 
6053 	if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6054 		scsi_cmd->result |= (DID_ERROR << 16);
6055 		scmd_printk(KERN_ERR, scsi_cmd,
6056 			    "Request Sense failed with IOASC: 0x%08X\n", ioasc);
6057 	} else {
6058 		memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
6059 		       SCSI_SENSE_BUFFERSIZE);
6060 	}
6061 
6062 	if (res) {
6063 		if (!ipr_is_naca_model(res))
6064 			res->needs_sync_complete = 1;
6065 		res->in_erp = 0;
6066 	}
6067 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
6068 	scsi_cmd->scsi_done(scsi_cmd);
6069 	if (ipr_cmd->eh_comp)
6070 		complete(ipr_cmd->eh_comp);
6071 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6072 }
6073 
6074 /**
6075  * ipr_erp_done - Process completion of ERP for a device
6076  * @ipr_cmd:		ipr command struct
6077  *
6078  * This function copies the sense buffer into the scsi_cmd
6079  * struct and pushes the scsi_done function.
6080  *
6081  * Return value:
6082  * 	nothing
6083  **/
6084 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6085 {
6086 	struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6087 	unsigned long hrrq_flags;
6088 
6089 	spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6090 	__ipr_erp_done(ipr_cmd);
6091 	spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6092 }
6093 
6094 /**
6095  * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
6096  * @ipr_cmd:	ipr command struct
6097  *
6098  * Return value:
6099  * 	none
6100  **/
6101 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
6102 {
6103 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6104 	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6105 	dma_addr_t dma_addr = ipr_cmd->dma_addr;
6106 
6107 	memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
6108 	ioarcb->data_transfer_length = 0;
6109 	ioarcb->read_data_transfer_length = 0;
6110 	ioarcb->ioadl_len = 0;
6111 	ioarcb->read_ioadl_len = 0;
6112 	ioasa->hdr.ioasc = 0;
6113 	ioasa->hdr.residual_data_len = 0;
6114 
6115 	if (ipr_cmd->ioa_cfg->sis64)
6116 		ioarcb->u.sis64_addr_data.data_ioadl_addr =
6117 			cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
6118 	else {
6119 		ioarcb->write_ioadl_addr =
6120 			cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
6121 		ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6122 	}
6123 }
6124 
6125 /**
6126  * __ipr_erp_request_sense - Send request sense to a device
6127  * @ipr_cmd:	ipr command struct
6128  *
6129  * This function sends a request sense to a device as a result
6130  * of a check condition.
6131  *
6132  * Return value:
6133  * 	nothing
6134  **/
6135 static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6136 {
6137 	struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6138 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6139 
6140 	if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6141 		__ipr_erp_done(ipr_cmd);
6142 		return;
6143 	}
6144 
6145 	ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6146 
6147 	cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
6148 	cmd_pkt->cdb[0] = REQUEST_SENSE;
6149 	cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
6150 	cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
6151 	cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6152 	cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
6153 
6154 	ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
6155 		       SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
6156 
6157 	ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
6158 		   IPR_REQUEST_SENSE_TIMEOUT * 2);
6159 }
6160 
6161 /**
6162  * ipr_erp_request_sense - Send request sense to a device
6163  * @ipr_cmd:	ipr command struct
6164  *
6165  * This function sends a request sense to a device as a result
6166  * of a check condition.
6167  *
6168  * Return value:
6169  * 	nothing
6170  **/
6171 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6172 {
6173 	struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6174 	unsigned long hrrq_flags;
6175 
6176 	spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6177 	__ipr_erp_request_sense(ipr_cmd);
6178 	spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6179 }
6180 
6181 /**
6182  * ipr_erp_cancel_all - Send cancel all to a device
6183  * @ipr_cmd:	ipr command struct
6184  *
6185  * This function sends a cancel all to a device to clear the
6186  * queue. If we are running TCQ on the device, QERR is set to 1,
6187  * which means all outstanding ops have been dropped on the floor.
6188  * Cancel all will return them to us.
6189  *
6190  * Return value:
6191  * 	nothing
6192  **/
6193 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
6194 {
6195 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6196 	struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6197 	struct ipr_cmd_pkt *cmd_pkt;
6198 
6199 	res->in_erp = 1;
6200 
6201 	ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6202 
6203 	if (!scsi_cmd->device->simple_tags) {
6204 		__ipr_erp_request_sense(ipr_cmd);
6205 		return;
6206 	}
6207 
6208 	cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6209 	cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
6210 	cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
6211 
6212 	ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
6213 		   IPR_CANCEL_ALL_TIMEOUT);
6214 }
6215 
6216 /**
6217  * ipr_dump_ioasa - Dump contents of IOASA
6218  * @ioa_cfg:	ioa config struct
6219  * @ipr_cmd:	ipr command struct
6220  * @res:		resource entry struct
6221  *
6222  * This function is invoked by the interrupt handler when ops
6223  * fail. It will log the IOASA if appropriate. Only called
6224  * for GPDD ops.
6225  *
6226  * Return value:
6227  * 	none
6228  **/
6229 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
6230 			   struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
6231 {
6232 	int i;
6233 	u16 data_len;
6234 	u32 ioasc, fd_ioasc;
6235 	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6236 	__be32 *ioasa_data = (__be32 *)ioasa;
6237 	int error_index;
6238 
6239 	ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
6240 	fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
6241 
6242 	if (0 == ioasc)
6243 		return;
6244 
6245 	if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
6246 		return;
6247 
6248 	if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
6249 		error_index = ipr_get_error(fd_ioasc);
6250 	else
6251 		error_index = ipr_get_error(ioasc);
6252 
6253 	if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
6254 		/* Don't log an error if the IOA already logged one */
6255 		if (ioasa->hdr.ilid != 0)
6256 			return;
6257 
6258 		if (!ipr_is_gscsi(res))
6259 			return;
6260 
6261 		if (ipr_error_table[error_index].log_ioasa == 0)
6262 			return;
6263 	}
6264 
6265 	ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
6266 
6267 	data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
6268 	if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
6269 		data_len = sizeof(struct ipr_ioasa64);
6270 	else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
6271 		data_len = sizeof(struct ipr_ioasa);
6272 
6273 	ipr_err("IOASA Dump:\n");
6274 
6275 	for (i = 0; i < data_len / 4; i += 4) {
6276 		ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
6277 			be32_to_cpu(ioasa_data[i]),
6278 			be32_to_cpu(ioasa_data[i+1]),
6279 			be32_to_cpu(ioasa_data[i+2]),
6280 			be32_to_cpu(ioasa_data[i+3]));
6281 	}
6282 }
6283 
6284 /**
6285  * ipr_gen_sense - Generate SCSI sense data from an IOASA
6286  * @ipr_cmd:	ipr command struct
6287  *
6288  * Return value:
6289  * 	none
6290  **/
6291 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
6292 {
6293 	u32 failing_lba;
6294 	u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
6295 	struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
6296 	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6297 	u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
6298 
6299 	memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
6300 
6301 	if (ioasc >= IPR_FIRST_DRIVER_IOASC)
6302 		return;
6303 
6304 	ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
6305 
6306 	if (ipr_is_vset_device(res) &&
6307 	    ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
6308 	    ioasa->u.vset.failing_lba_hi != 0) {
6309 		sense_buf[0] = 0x72;
6310 		sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
6311 		sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
6312 		sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
6313 
6314 		sense_buf[7] = 12;
6315 		sense_buf[8] = 0;
6316 		sense_buf[9] = 0x0A;
6317 		sense_buf[10] = 0x80;
6318 
6319 		failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
6320 
6321 		sense_buf[12] = (failing_lba & 0xff000000) >> 24;
6322 		sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
6323 		sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
6324 		sense_buf[15] = failing_lba & 0x000000ff;
6325 
6326 		failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6327 
6328 		sense_buf[16] = (failing_lba & 0xff000000) >> 24;
6329 		sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
6330 		sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
6331 		sense_buf[19] = failing_lba & 0x000000ff;
6332 	} else {
6333 		sense_buf[0] = 0x70;
6334 		sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
6335 		sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
6336 		sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
6337 
6338 		/* Illegal request */
6339 		if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
6340 		    (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
6341 			sense_buf[7] = 10;	/* additional length */
6342 
6343 			/* IOARCB was in error */
6344 			if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
6345 				sense_buf[15] = 0xC0;
6346 			else	/* Parameter data was invalid */
6347 				sense_buf[15] = 0x80;
6348 
6349 			sense_buf[16] =
6350 			    ((IPR_FIELD_POINTER_MASK &
6351 			      be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
6352 			sense_buf[17] =
6353 			    (IPR_FIELD_POINTER_MASK &
6354 			     be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
6355 		} else {
6356 			if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
6357 				if (ipr_is_vset_device(res))
6358 					failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6359 				else
6360 					failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
6361 
6362 				sense_buf[0] |= 0x80;	/* Or in the Valid bit */
6363 				sense_buf[3] = (failing_lba & 0xff000000) >> 24;
6364 				sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
6365 				sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
6366 				sense_buf[6] = failing_lba & 0x000000ff;
6367 			}
6368 
6369 			sense_buf[7] = 6;	/* additional length */
6370 		}
6371 	}
6372 }
6373 
6374 /**
6375  * ipr_get_autosense - Copy autosense data to sense buffer
6376  * @ipr_cmd:	ipr command struct
6377  *
6378  * This function copies the autosense buffer to the buffer
6379  * in the scsi_cmd, if there is autosense available.
6380  *
6381  * Return value:
6382  *	1 if autosense was available / 0 if not
6383  **/
6384 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
6385 {
6386 	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6387 	struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
6388 
6389 	if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
6390 		return 0;
6391 
6392 	if (ipr_cmd->ioa_cfg->sis64)
6393 		memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
6394 		       min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
6395 			   SCSI_SENSE_BUFFERSIZE));
6396 	else
6397 		memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
6398 		       min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
6399 			   SCSI_SENSE_BUFFERSIZE));
6400 	return 1;
6401 }
6402 
6403 /**
6404  * ipr_erp_start - Process an error response for a SCSI op
6405  * @ioa_cfg:	ioa config struct
6406  * @ipr_cmd:	ipr command struct
6407  *
6408  * This function determines whether or not to initiate ERP
6409  * on the affected device.
6410  *
6411  * Return value:
6412  * 	nothing
6413  **/
6414 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
6415 			      struct ipr_cmnd *ipr_cmd)
6416 {
6417 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6418 	struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6419 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6420 	u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
6421 
6422 	if (!res) {
6423 		__ipr_scsi_eh_done(ipr_cmd);
6424 		return;
6425 	}
6426 
6427 	if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
6428 		ipr_gen_sense(ipr_cmd);
6429 
6430 	ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6431 
6432 	switch (masked_ioasc) {
6433 	case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
6434 		if (ipr_is_naca_model(res))
6435 			scsi_cmd->result |= (DID_ABORT << 16);
6436 		else
6437 			scsi_cmd->result |= (DID_IMM_RETRY << 16);
6438 		break;
6439 	case IPR_IOASC_IR_RESOURCE_HANDLE:
6440 	case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
6441 		scsi_cmd->result |= (DID_NO_CONNECT << 16);
6442 		break;
6443 	case IPR_IOASC_HW_SEL_TIMEOUT:
6444 		scsi_cmd->result |= (DID_NO_CONNECT << 16);
6445 		if (!ipr_is_naca_model(res))
6446 			res->needs_sync_complete = 1;
6447 		break;
6448 	case IPR_IOASC_SYNC_REQUIRED:
6449 		if (!res->in_erp)
6450 			res->needs_sync_complete = 1;
6451 		scsi_cmd->result |= (DID_IMM_RETRY << 16);
6452 		break;
6453 	case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
6454 	case IPR_IOASA_IR_DUAL_IOA_DISABLED:
6455 		/*
6456 		 * exception: do not set DID_PASSTHROUGH on CHECK CONDITION
6457 		 * so SCSI mid-layer and upper layers handle it accordingly.
6458 		 */
6459 		if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION)
6460 			scsi_cmd->result |= (DID_PASSTHROUGH << 16);
6461 		break;
6462 	case IPR_IOASC_BUS_WAS_RESET:
6463 	case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
6464 		/*
6465 		 * Report the bus reset and ask for a retry. The device
6466 		 * will give CC/UA the next command.
6467 		 */
6468 		if (!res->resetting_device)
6469 			scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
6470 		scsi_cmd->result |= (DID_ERROR << 16);
6471 		if (!ipr_is_naca_model(res))
6472 			res->needs_sync_complete = 1;
6473 		break;
6474 	case IPR_IOASC_HW_DEV_BUS_STATUS:
6475 		scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
6476 		if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
6477 			if (!ipr_get_autosense(ipr_cmd)) {
6478 				if (!ipr_is_naca_model(res)) {
6479 					ipr_erp_cancel_all(ipr_cmd);
6480 					return;
6481 				}
6482 			}
6483 		}
6484 		if (!ipr_is_naca_model(res))
6485 			res->needs_sync_complete = 1;
6486 		break;
6487 	case IPR_IOASC_NR_INIT_CMD_REQUIRED:
6488 		break;
6489 	case IPR_IOASC_IR_NON_OPTIMIZED:
6490 		if (res->raw_mode) {
6491 			res->raw_mode = 0;
6492 			scsi_cmd->result |= (DID_IMM_RETRY << 16);
6493 		} else
6494 			scsi_cmd->result |= (DID_ERROR << 16);
6495 		break;
6496 	default:
6497 		if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6498 			scsi_cmd->result |= (DID_ERROR << 16);
6499 		if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
6500 			res->needs_sync_complete = 1;
6501 		break;
6502 	}
6503 
6504 	scsi_dma_unmap(ipr_cmd->scsi_cmd);
6505 	scsi_cmd->scsi_done(scsi_cmd);
6506 	if (ipr_cmd->eh_comp)
6507 		complete(ipr_cmd->eh_comp);
6508 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6509 }
6510 
6511 /**
6512  * ipr_scsi_done - mid-layer done function
6513  * @ipr_cmd:	ipr command struct
6514  *
6515  * This function is invoked by the interrupt handler for
6516  * ops generated by the SCSI mid-layer
6517  *
6518  * Return value:
6519  * 	none
6520  **/
6521 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
6522 {
6523 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6524 	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6525 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6526 	unsigned long lock_flags;
6527 
6528 	scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
6529 
6530 	if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
6531 		scsi_dma_unmap(scsi_cmd);
6532 
6533 		spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags);
6534 		scsi_cmd->scsi_done(scsi_cmd);
6535 		if (ipr_cmd->eh_comp)
6536 			complete(ipr_cmd->eh_comp);
6537 		list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6538 		spin_unlock_irqrestore(ipr_cmd->hrrq->lock, lock_flags);
6539 	} else {
6540 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6541 		spin_lock(&ipr_cmd->hrrq->_lock);
6542 		ipr_erp_start(ioa_cfg, ipr_cmd);
6543 		spin_unlock(&ipr_cmd->hrrq->_lock);
6544 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6545 	}
6546 }
6547 
6548 /**
6549  * ipr_queuecommand - Queue a mid-layer request
6550  * @shost:		scsi host struct
6551  * @scsi_cmd:	scsi command struct
6552  *
6553  * This function queues a request generated by the mid-layer.
6554  *
6555  * Return value:
6556  *	0 on success
6557  *	SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6558  *	SCSI_MLQUEUE_HOST_BUSY if host is busy
6559  **/
6560 static int ipr_queuecommand(struct Scsi_Host *shost,
6561 			    struct scsi_cmnd *scsi_cmd)
6562 {
6563 	struct ipr_ioa_cfg *ioa_cfg;
6564 	struct ipr_resource_entry *res;
6565 	struct ipr_ioarcb *ioarcb;
6566 	struct ipr_cmnd *ipr_cmd;
6567 	unsigned long hrrq_flags, lock_flags;
6568 	int rc;
6569 	struct ipr_hrr_queue *hrrq;
6570 	int hrrq_id;
6571 
6572 	ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
6573 
6574 	scsi_cmd->result = (DID_OK << 16);
6575 	res = scsi_cmd->device->hostdata;
6576 
6577 	if (ipr_is_gata(res) && res->sata_port) {
6578 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6579 		rc = ata_sas_queuecmd(scsi_cmd, res->sata_port->ap);
6580 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6581 		return rc;
6582 	}
6583 
6584 	hrrq_id = ipr_get_hrrq_index(ioa_cfg);
6585 	hrrq = &ioa_cfg->hrrq[hrrq_id];
6586 
6587 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
6588 	/*
6589 	 * We are currently blocking all devices due to a host reset
6590 	 * We have told the host to stop giving us new requests, but
6591 	 * ERP ops don't count. FIXME
6592 	 */
6593 	if (unlikely(!hrrq->allow_cmds && !hrrq->ioa_is_dead && !hrrq->removing_ioa)) {
6594 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6595 		return SCSI_MLQUEUE_HOST_BUSY;
6596 	}
6597 
6598 	/*
6599 	 * FIXME - Create scsi_set_host_offline interface
6600 	 *  and the ioa_is_dead check can be removed
6601 	 */
6602 	if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) {
6603 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6604 		goto err_nodev;
6605 	}
6606 
6607 	ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
6608 	if (ipr_cmd == NULL) {
6609 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6610 		return SCSI_MLQUEUE_HOST_BUSY;
6611 	}
6612 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6613 
6614 	ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done);
6615 	ioarcb = &ipr_cmd->ioarcb;
6616 
6617 	memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
6618 	ipr_cmd->scsi_cmd = scsi_cmd;
6619 	ipr_cmd->done = ipr_scsi_eh_done;
6620 
6621 	if (ipr_is_gscsi(res)) {
6622 		if (scsi_cmd->underflow == 0)
6623 			ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6624 
6625 		if (res->reset_occurred) {
6626 			res->reset_occurred = 0;
6627 			ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
6628 		}
6629 	}
6630 
6631 	if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
6632 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
6633 
6634 		ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
6635 		if (scsi_cmd->flags & SCMD_TAGGED)
6636 			ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK;
6637 		else
6638 			ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
6639 	}
6640 
6641 	if (scsi_cmd->cmnd[0] >= 0xC0 &&
6642 	    (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE)) {
6643 		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
6644 	}
6645 	if (res->raw_mode && ipr_is_af_dasd_device(res)) {
6646 		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE;
6647 
6648 		if (scsi_cmd->underflow == 0)
6649 			ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6650 	}
6651 
6652 	if (ioa_cfg->sis64)
6653 		rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
6654 	else
6655 		rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
6656 
6657 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
6658 	if (unlikely(rc || (!hrrq->allow_cmds && !hrrq->ioa_is_dead))) {
6659 		list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6660 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6661 		if (!rc)
6662 			scsi_dma_unmap(scsi_cmd);
6663 		return SCSI_MLQUEUE_HOST_BUSY;
6664 	}
6665 
6666 	if (unlikely(hrrq->ioa_is_dead)) {
6667 		list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6668 		spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6669 		scsi_dma_unmap(scsi_cmd);
6670 		goto err_nodev;
6671 	}
6672 
6673 	ioarcb->res_handle = res->res_handle;
6674 	if (res->needs_sync_complete) {
6675 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
6676 		res->needs_sync_complete = 0;
6677 	}
6678 	list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_pending_q);
6679 	ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
6680 	ipr_send_command(ipr_cmd);
6681 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6682 	return 0;
6683 
6684 err_nodev:
6685 	spin_lock_irqsave(hrrq->lock, hrrq_flags);
6686 	memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
6687 	scsi_cmd->result = (DID_NO_CONNECT << 16);
6688 	scsi_cmd->scsi_done(scsi_cmd);
6689 	spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6690 	return 0;
6691 }
6692 
6693 /**
6694  * ipr_ioctl - IOCTL handler
6695  * @sdev:	scsi device struct
6696  * @cmd:	IOCTL cmd
6697  * @arg:	IOCTL arg
6698  *
6699  * Return value:
6700  * 	0 on success / other on failure
6701  **/
6702 static int ipr_ioctl(struct scsi_device *sdev, unsigned int cmd,
6703 		     void __user *arg)
6704 {
6705 	struct ipr_resource_entry *res;
6706 
6707 	res = (struct ipr_resource_entry *)sdev->hostdata;
6708 	if (res && ipr_is_gata(res)) {
6709 		if (cmd == HDIO_GET_IDENTITY)
6710 			return -ENOTTY;
6711 		return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
6712 	}
6713 
6714 	return -EINVAL;
6715 }
6716 
6717 /**
6718  * ipr_ioa_info - Get information about the card/driver
6719  * @host:	scsi host struct
6720  *
6721  * Return value:
6722  * 	pointer to buffer with description string
6723  **/
6724 static const char *ipr_ioa_info(struct Scsi_Host *host)
6725 {
6726 	static char buffer[512];
6727 	struct ipr_ioa_cfg *ioa_cfg;
6728 	unsigned long lock_flags = 0;
6729 
6730 	ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
6731 
6732 	spin_lock_irqsave(host->host_lock, lock_flags);
6733 	sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
6734 	spin_unlock_irqrestore(host->host_lock, lock_flags);
6735 
6736 	return buffer;
6737 }
6738 
6739 static struct scsi_host_template driver_template = {
6740 	.module = THIS_MODULE,
6741 	.name = "IPR",
6742 	.info = ipr_ioa_info,
6743 	.ioctl = ipr_ioctl,
6744 #ifdef CONFIG_COMPAT
6745 	.compat_ioctl = ipr_ioctl,
6746 #endif
6747 	.queuecommand = ipr_queuecommand,
6748 	.dma_need_drain = ata_scsi_dma_need_drain,
6749 	.eh_abort_handler = ipr_eh_abort,
6750 	.eh_device_reset_handler = ipr_eh_dev_reset,
6751 	.eh_host_reset_handler = ipr_eh_host_reset,
6752 	.slave_alloc = ipr_slave_alloc,
6753 	.slave_configure = ipr_slave_configure,
6754 	.slave_destroy = ipr_slave_destroy,
6755 	.scan_finished = ipr_scan_finished,
6756 	.target_alloc = ipr_target_alloc,
6757 	.target_destroy = ipr_target_destroy,
6758 	.change_queue_depth = ipr_change_queue_depth,
6759 	.bios_param = ipr_biosparam,
6760 	.can_queue = IPR_MAX_COMMANDS,
6761 	.this_id = -1,
6762 	.sg_tablesize = IPR_MAX_SGLIST,
6763 	.max_sectors = IPR_IOA_MAX_SECTORS,
6764 	.cmd_per_lun = IPR_MAX_CMD_PER_LUN,
6765 	.shost_attrs = ipr_ioa_attrs,
6766 	.sdev_attrs = ipr_dev_attrs,
6767 	.proc_name = IPR_NAME,
6768 };
6769 
6770 /**
6771  * ipr_ata_phy_reset - libata phy_reset handler
6772  * @ap:		ata port to reset
6773  *
6774  **/
6775 static void ipr_ata_phy_reset(struct ata_port *ap)
6776 {
6777 	unsigned long flags;
6778 	struct ipr_sata_port *sata_port = ap->private_data;
6779 	struct ipr_resource_entry *res = sata_port->res;
6780 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6781 	int rc;
6782 
6783 	ENTER;
6784 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6785 	while (ioa_cfg->in_reset_reload) {
6786 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6787 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6788 		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6789 	}
6790 
6791 	if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds)
6792 		goto out_unlock;
6793 
6794 	rc = ipr_device_reset(ioa_cfg, res);
6795 
6796 	if (rc) {
6797 		ap->link.device[0].class = ATA_DEV_NONE;
6798 		goto out_unlock;
6799 	}
6800 
6801 	ap->link.device[0].class = res->ata_class;
6802 	if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
6803 		ap->link.device[0].class = ATA_DEV_NONE;
6804 
6805 out_unlock:
6806 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6807 	LEAVE;
6808 }
6809 
6810 /**
6811  * ipr_ata_post_internal - Cleanup after an internal command
6812  * @qc:	ATA queued command
6813  *
6814  * Return value:
6815  * 	none
6816  **/
6817 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
6818 {
6819 	struct ipr_sata_port *sata_port = qc->ap->private_data;
6820 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6821 	struct ipr_cmnd *ipr_cmd;
6822 	struct ipr_hrr_queue *hrrq;
6823 	unsigned long flags;
6824 
6825 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6826 	while (ioa_cfg->in_reset_reload) {
6827 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6828 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6829 		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6830 	}
6831 
6832 	for_each_hrrq(hrrq, ioa_cfg) {
6833 		spin_lock(&hrrq->_lock);
6834 		list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
6835 			if (ipr_cmd->qc == qc) {
6836 				ipr_device_reset(ioa_cfg, sata_port->res);
6837 				break;
6838 			}
6839 		}
6840 		spin_unlock(&hrrq->_lock);
6841 	}
6842 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6843 }
6844 
6845 /**
6846  * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6847  * @regs:	destination
6848  * @tf:	source ATA taskfile
6849  *
6850  * Return value:
6851  * 	none
6852  **/
6853 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
6854 			     struct ata_taskfile *tf)
6855 {
6856 	regs->feature = tf->feature;
6857 	regs->nsect = tf->nsect;
6858 	regs->lbal = tf->lbal;
6859 	regs->lbam = tf->lbam;
6860 	regs->lbah = tf->lbah;
6861 	regs->device = tf->device;
6862 	regs->command = tf->command;
6863 	regs->hob_feature = tf->hob_feature;
6864 	regs->hob_nsect = tf->hob_nsect;
6865 	regs->hob_lbal = tf->hob_lbal;
6866 	regs->hob_lbam = tf->hob_lbam;
6867 	regs->hob_lbah = tf->hob_lbah;
6868 	regs->ctl = tf->ctl;
6869 }
6870 
6871 /**
6872  * ipr_sata_done - done function for SATA commands
6873  * @ipr_cmd:	ipr command struct
6874  *
6875  * This function is invoked by the interrupt handler for
6876  * ops generated by the SCSI mid-layer to SATA devices
6877  *
6878  * Return value:
6879  * 	none
6880  **/
6881 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
6882 {
6883 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6884 	struct ata_queued_cmd *qc = ipr_cmd->qc;
6885 	struct ipr_sata_port *sata_port = qc->ap->private_data;
6886 	struct ipr_resource_entry *res = sata_port->res;
6887 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6888 
6889 	spin_lock(&ipr_cmd->hrrq->_lock);
6890 	if (ipr_cmd->ioa_cfg->sis64)
6891 		memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
6892 		       sizeof(struct ipr_ioasa_gata));
6893 	else
6894 		memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
6895 		       sizeof(struct ipr_ioasa_gata));
6896 	ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6897 
6898 	if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
6899 		scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
6900 
6901 	if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6902 		qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
6903 	else
6904 		qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
6905 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6906 	spin_unlock(&ipr_cmd->hrrq->_lock);
6907 	ata_qc_complete(qc);
6908 }
6909 
6910 /**
6911  * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6912  * @ipr_cmd:	ipr command struct
6913  * @qc:		ATA queued command
6914  *
6915  **/
6916 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
6917 				  struct ata_queued_cmd *qc)
6918 {
6919 	u32 ioadl_flags = 0;
6920 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6921 	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64;
6922 	struct ipr_ioadl64_desc *last_ioadl64 = NULL;
6923 	int len = qc->nbytes;
6924 	struct scatterlist *sg;
6925 	unsigned int si;
6926 	dma_addr_t dma_addr = ipr_cmd->dma_addr;
6927 
6928 	if (len == 0)
6929 		return;
6930 
6931 	if (qc->dma_dir == DMA_TO_DEVICE) {
6932 		ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6933 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6934 	} else if (qc->dma_dir == DMA_FROM_DEVICE)
6935 		ioadl_flags = IPR_IOADL_FLAGS_READ;
6936 
6937 	ioarcb->data_transfer_length = cpu_to_be32(len);
6938 	ioarcb->ioadl_len =
6939 		cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
6940 	ioarcb->u.sis64_addr_data.data_ioadl_addr =
6941 		cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64));
6942 
6943 	for_each_sg(qc->sg, sg, qc->n_elem, si) {
6944 		ioadl64->flags = cpu_to_be32(ioadl_flags);
6945 		ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
6946 		ioadl64->address = cpu_to_be64(sg_dma_address(sg));
6947 
6948 		last_ioadl64 = ioadl64;
6949 		ioadl64++;
6950 	}
6951 
6952 	if (likely(last_ioadl64))
6953 		last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6954 }
6955 
6956 /**
6957  * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6958  * @ipr_cmd:	ipr command struct
6959  * @qc:		ATA queued command
6960  *
6961  **/
6962 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
6963 				struct ata_queued_cmd *qc)
6964 {
6965 	u32 ioadl_flags = 0;
6966 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6967 	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
6968 	struct ipr_ioadl_desc *last_ioadl = NULL;
6969 	int len = qc->nbytes;
6970 	struct scatterlist *sg;
6971 	unsigned int si;
6972 
6973 	if (len == 0)
6974 		return;
6975 
6976 	if (qc->dma_dir == DMA_TO_DEVICE) {
6977 		ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6978 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6979 		ioarcb->data_transfer_length = cpu_to_be32(len);
6980 		ioarcb->ioadl_len =
6981 			cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6982 	} else if (qc->dma_dir == DMA_FROM_DEVICE) {
6983 		ioadl_flags = IPR_IOADL_FLAGS_READ;
6984 		ioarcb->read_data_transfer_length = cpu_to_be32(len);
6985 		ioarcb->read_ioadl_len =
6986 			cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6987 	}
6988 
6989 	for_each_sg(qc->sg, sg, qc->n_elem, si) {
6990 		ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6991 		ioadl->address = cpu_to_be32(sg_dma_address(sg));
6992 
6993 		last_ioadl = ioadl;
6994 		ioadl++;
6995 	}
6996 
6997 	if (likely(last_ioadl))
6998 		last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6999 }
7000 
7001 /**
7002  * ipr_qc_defer - Get a free ipr_cmd
7003  * @qc:	queued command
7004  *
7005  * Return value:
7006  *	0 if success
7007  **/
7008 static int ipr_qc_defer(struct ata_queued_cmd *qc)
7009 {
7010 	struct ata_port *ap = qc->ap;
7011 	struct ipr_sata_port *sata_port = ap->private_data;
7012 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
7013 	struct ipr_cmnd *ipr_cmd;
7014 	struct ipr_hrr_queue *hrrq;
7015 	int hrrq_id;
7016 
7017 	hrrq_id = ipr_get_hrrq_index(ioa_cfg);
7018 	hrrq = &ioa_cfg->hrrq[hrrq_id];
7019 
7020 	qc->lldd_task = NULL;
7021 	spin_lock(&hrrq->_lock);
7022 	if (unlikely(hrrq->ioa_is_dead)) {
7023 		spin_unlock(&hrrq->_lock);
7024 		return 0;
7025 	}
7026 
7027 	if (unlikely(!hrrq->allow_cmds)) {
7028 		spin_unlock(&hrrq->_lock);
7029 		return ATA_DEFER_LINK;
7030 	}
7031 
7032 	ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
7033 	if (ipr_cmd == NULL) {
7034 		spin_unlock(&hrrq->_lock);
7035 		return ATA_DEFER_LINK;
7036 	}
7037 
7038 	qc->lldd_task = ipr_cmd;
7039 	spin_unlock(&hrrq->_lock);
7040 	return 0;
7041 }
7042 
7043 /**
7044  * ipr_qc_issue - Issue a SATA qc to a device
7045  * @qc:	queued command
7046  *
7047  * Return value:
7048  * 	0 if success
7049  **/
7050 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
7051 {
7052 	struct ata_port *ap = qc->ap;
7053 	struct ipr_sata_port *sata_port = ap->private_data;
7054 	struct ipr_resource_entry *res = sata_port->res;
7055 	struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
7056 	struct ipr_cmnd *ipr_cmd;
7057 	struct ipr_ioarcb *ioarcb;
7058 	struct ipr_ioarcb_ata_regs *regs;
7059 
7060 	if (qc->lldd_task == NULL)
7061 		ipr_qc_defer(qc);
7062 
7063 	ipr_cmd = qc->lldd_task;
7064 	if (ipr_cmd == NULL)
7065 		return AC_ERR_SYSTEM;
7066 
7067 	qc->lldd_task = NULL;
7068 	spin_lock(&ipr_cmd->hrrq->_lock);
7069 	if (unlikely(!ipr_cmd->hrrq->allow_cmds ||
7070 			ipr_cmd->hrrq->ioa_is_dead)) {
7071 		list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7072 		spin_unlock(&ipr_cmd->hrrq->_lock);
7073 		return AC_ERR_SYSTEM;
7074 	}
7075 
7076 	ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
7077 	ioarcb = &ipr_cmd->ioarcb;
7078 
7079 	if (ioa_cfg->sis64) {
7080 		regs = &ipr_cmd->i.ata_ioadl.regs;
7081 		ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
7082 	} else
7083 		regs = &ioarcb->u.add_data.u.regs;
7084 
7085 	memset(regs, 0, sizeof(*regs));
7086 	ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
7087 
7088 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
7089 	ipr_cmd->qc = qc;
7090 	ipr_cmd->done = ipr_sata_done;
7091 	ipr_cmd->ioarcb.res_handle = res->res_handle;
7092 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
7093 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
7094 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
7095 	ipr_cmd->dma_use_sg = qc->n_elem;
7096 
7097 	if (ioa_cfg->sis64)
7098 		ipr_build_ata_ioadl64(ipr_cmd, qc);
7099 	else
7100 		ipr_build_ata_ioadl(ipr_cmd, qc);
7101 
7102 	regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
7103 	ipr_copy_sata_tf(regs, &qc->tf);
7104 	memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
7105 	ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
7106 
7107 	switch (qc->tf.protocol) {
7108 	case ATA_PROT_NODATA:
7109 	case ATA_PROT_PIO:
7110 		break;
7111 
7112 	case ATA_PROT_DMA:
7113 		regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7114 		break;
7115 
7116 	case ATAPI_PROT_PIO:
7117 	case ATAPI_PROT_NODATA:
7118 		regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7119 		break;
7120 
7121 	case ATAPI_PROT_DMA:
7122 		regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7123 		regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7124 		break;
7125 
7126 	default:
7127 		WARN_ON(1);
7128 		spin_unlock(&ipr_cmd->hrrq->_lock);
7129 		return AC_ERR_INVALID;
7130 	}
7131 
7132 	ipr_send_command(ipr_cmd);
7133 	spin_unlock(&ipr_cmd->hrrq->_lock);
7134 
7135 	return 0;
7136 }
7137 
7138 /**
7139  * ipr_qc_fill_rtf - Read result TF
7140  * @qc: ATA queued command
7141  *
7142  * Return value:
7143  * 	true
7144  **/
7145 static bool ipr_qc_fill_rtf(struct ata_queued_cmd *qc)
7146 {
7147 	struct ipr_sata_port *sata_port = qc->ap->private_data;
7148 	struct ipr_ioasa_gata *g = &sata_port->ioasa;
7149 	struct ata_taskfile *tf = &qc->result_tf;
7150 
7151 	tf->feature = g->error;
7152 	tf->nsect = g->nsect;
7153 	tf->lbal = g->lbal;
7154 	tf->lbam = g->lbam;
7155 	tf->lbah = g->lbah;
7156 	tf->device = g->device;
7157 	tf->command = g->status;
7158 	tf->hob_nsect = g->hob_nsect;
7159 	tf->hob_lbal = g->hob_lbal;
7160 	tf->hob_lbam = g->hob_lbam;
7161 	tf->hob_lbah = g->hob_lbah;
7162 
7163 	return true;
7164 }
7165 
7166 static struct ata_port_operations ipr_sata_ops = {
7167 	.phy_reset = ipr_ata_phy_reset,
7168 	.hardreset = ipr_sata_reset,
7169 	.post_internal_cmd = ipr_ata_post_internal,
7170 	.qc_prep = ata_noop_qc_prep,
7171 	.qc_defer = ipr_qc_defer,
7172 	.qc_issue = ipr_qc_issue,
7173 	.qc_fill_rtf = ipr_qc_fill_rtf,
7174 	.port_start = ata_sas_port_start,
7175 	.port_stop = ata_sas_port_stop
7176 };
7177 
7178 static struct ata_port_info sata_port_info = {
7179 	.flags		= ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
7180 			  ATA_FLAG_SAS_HOST,
7181 	.pio_mask	= ATA_PIO4_ONLY,
7182 	.mwdma_mask	= ATA_MWDMA2,
7183 	.udma_mask	= ATA_UDMA6,
7184 	.port_ops	= &ipr_sata_ops
7185 };
7186 
7187 #ifdef CONFIG_PPC_PSERIES
7188 static const u16 ipr_blocked_processors[] = {
7189 	PVR_NORTHSTAR,
7190 	PVR_PULSAR,
7191 	PVR_POWER4,
7192 	PVR_ICESTAR,
7193 	PVR_SSTAR,
7194 	PVR_POWER4p,
7195 	PVR_630,
7196 	PVR_630p
7197 };
7198 
7199 /**
7200  * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
7201  * @ioa_cfg:	ioa cfg struct
7202  *
7203  * Adapters that use Gemstone revision < 3.1 do not work reliably on
7204  * certain pSeries hardware. This function determines if the given
7205  * adapter is in one of these confgurations or not.
7206  *
7207  * Return value:
7208  * 	1 if adapter is not supported / 0 if adapter is supported
7209  **/
7210 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
7211 {
7212 	int i;
7213 
7214 	if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
7215 		for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
7216 			if (pvr_version_is(ipr_blocked_processors[i]))
7217 				return 1;
7218 		}
7219 	}
7220 	return 0;
7221 }
7222 #else
7223 #define ipr_invalid_adapter(ioa_cfg) 0
7224 #endif
7225 
7226 /**
7227  * ipr_ioa_bringdown_done - IOA bring down completion.
7228  * @ipr_cmd:	ipr command struct
7229  *
7230  * This function processes the completion of an adapter bring down.
7231  * It wakes any reset sleepers.
7232  *
7233  * Return value:
7234  * 	IPR_RC_JOB_RETURN
7235  **/
7236 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
7237 {
7238 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7239 	int i;
7240 
7241 	ENTER;
7242 	if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
7243 		ipr_trace;
7244 		ioa_cfg->scsi_unblock = 1;
7245 		schedule_work(&ioa_cfg->work_q);
7246 	}
7247 
7248 	ioa_cfg->in_reset_reload = 0;
7249 	ioa_cfg->reset_retries = 0;
7250 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
7251 		spin_lock(&ioa_cfg->hrrq[i]._lock);
7252 		ioa_cfg->hrrq[i].ioa_is_dead = 1;
7253 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
7254 	}
7255 	wmb();
7256 
7257 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7258 	wake_up_all(&ioa_cfg->reset_wait_q);
7259 	LEAVE;
7260 
7261 	return IPR_RC_JOB_RETURN;
7262 }
7263 
7264 /**
7265  * ipr_ioa_reset_done - IOA reset completion.
7266  * @ipr_cmd:	ipr command struct
7267  *
7268  * This function processes the completion of an adapter reset.
7269  * It schedules any necessary mid-layer add/removes and
7270  * wakes any reset sleepers.
7271  *
7272  * Return value:
7273  * 	IPR_RC_JOB_RETURN
7274  **/
7275 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
7276 {
7277 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7278 	struct ipr_resource_entry *res;
7279 	int j;
7280 
7281 	ENTER;
7282 	ioa_cfg->in_reset_reload = 0;
7283 	for (j = 0; j < ioa_cfg->hrrq_num; j++) {
7284 		spin_lock(&ioa_cfg->hrrq[j]._lock);
7285 		ioa_cfg->hrrq[j].allow_cmds = 1;
7286 		spin_unlock(&ioa_cfg->hrrq[j]._lock);
7287 	}
7288 	wmb();
7289 	ioa_cfg->reset_cmd = NULL;
7290 	ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
7291 
7292 	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
7293 		if (res->add_to_ml || res->del_from_ml) {
7294 			ipr_trace;
7295 			break;
7296 		}
7297 	}
7298 	schedule_work(&ioa_cfg->work_q);
7299 
7300 	for (j = 0; j < IPR_NUM_HCAMS; j++) {
7301 		list_del_init(&ioa_cfg->hostrcb[j]->queue);
7302 		if (j < IPR_NUM_LOG_HCAMS)
7303 			ipr_send_hcam(ioa_cfg,
7304 				IPR_HCAM_CDB_OP_CODE_LOG_DATA,
7305 				ioa_cfg->hostrcb[j]);
7306 		else
7307 			ipr_send_hcam(ioa_cfg,
7308 				IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
7309 				ioa_cfg->hostrcb[j]);
7310 	}
7311 
7312 	scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
7313 	dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
7314 
7315 	ioa_cfg->reset_retries = 0;
7316 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7317 	wake_up_all(&ioa_cfg->reset_wait_q);
7318 
7319 	ioa_cfg->scsi_unblock = 1;
7320 	schedule_work(&ioa_cfg->work_q);
7321 	LEAVE;
7322 	return IPR_RC_JOB_RETURN;
7323 }
7324 
7325 /**
7326  * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7327  * @supported_dev:	supported device struct
7328  * @vpids:			vendor product id struct
7329  *
7330  * Return value:
7331  * 	none
7332  **/
7333 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
7334 				 struct ipr_std_inq_vpids *vpids)
7335 {
7336 	memset(supported_dev, 0, sizeof(struct ipr_supported_device));
7337 	memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
7338 	supported_dev->num_records = 1;
7339 	supported_dev->data_length =
7340 		cpu_to_be16(sizeof(struct ipr_supported_device));
7341 	supported_dev->reserved = 0;
7342 }
7343 
7344 /**
7345  * ipr_set_supported_devs - Send Set Supported Devices for a device
7346  * @ipr_cmd:	ipr command struct
7347  *
7348  * This function sends a Set Supported Devices to the adapter
7349  *
7350  * Return value:
7351  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7352  **/
7353 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
7354 {
7355 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7356 	struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
7357 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7358 	struct ipr_resource_entry *res = ipr_cmd->u.res;
7359 
7360 	ipr_cmd->job_step = ipr_ioa_reset_done;
7361 
7362 	list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
7363 		if (!ipr_is_scsi_disk(res))
7364 			continue;
7365 
7366 		ipr_cmd->u.res = res;
7367 		ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
7368 
7369 		ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7370 		ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7371 		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7372 
7373 		ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
7374 		ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
7375 		ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
7376 		ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
7377 
7378 		ipr_init_ioadl(ipr_cmd,
7379 			       ioa_cfg->vpd_cbs_dma +
7380 				 offsetof(struct ipr_misc_cbs, supp_dev),
7381 			       sizeof(struct ipr_supported_device),
7382 			       IPR_IOADL_FLAGS_WRITE_LAST);
7383 
7384 		ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7385 			   IPR_SET_SUP_DEVICE_TIMEOUT);
7386 
7387 		if (!ioa_cfg->sis64)
7388 			ipr_cmd->job_step = ipr_set_supported_devs;
7389 		LEAVE;
7390 		return IPR_RC_JOB_RETURN;
7391 	}
7392 
7393 	LEAVE;
7394 	return IPR_RC_JOB_CONTINUE;
7395 }
7396 
7397 /**
7398  * ipr_get_mode_page - Locate specified mode page
7399  * @mode_pages:	mode page buffer
7400  * @page_code:	page code to find
7401  * @len:		minimum required length for mode page
7402  *
7403  * Return value:
7404  * 	pointer to mode page / NULL on failure
7405  **/
7406 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
7407 			       u32 page_code, u32 len)
7408 {
7409 	struct ipr_mode_page_hdr *mode_hdr;
7410 	u32 page_length;
7411 	u32 length;
7412 
7413 	if (!mode_pages || (mode_pages->hdr.length == 0))
7414 		return NULL;
7415 
7416 	length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
7417 	mode_hdr = (struct ipr_mode_page_hdr *)
7418 		(mode_pages->data + mode_pages->hdr.block_desc_len);
7419 
7420 	while (length) {
7421 		if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
7422 			if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
7423 				return mode_hdr;
7424 			break;
7425 		} else {
7426 			page_length = (sizeof(struct ipr_mode_page_hdr) +
7427 				       mode_hdr->page_length);
7428 			length -= page_length;
7429 			mode_hdr = (struct ipr_mode_page_hdr *)
7430 				((unsigned long)mode_hdr + page_length);
7431 		}
7432 	}
7433 	return NULL;
7434 }
7435 
7436 /**
7437  * ipr_check_term_power - Check for term power errors
7438  * @ioa_cfg:	ioa config struct
7439  * @mode_pages:	IOAFP mode pages buffer
7440  *
7441  * Check the IOAFP's mode page 28 for term power errors
7442  *
7443  * Return value:
7444  * 	nothing
7445  **/
7446 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
7447 				 struct ipr_mode_pages *mode_pages)
7448 {
7449 	int i;
7450 	int entry_length;
7451 	struct ipr_dev_bus_entry *bus;
7452 	struct ipr_mode_page28 *mode_page;
7453 
7454 	mode_page = ipr_get_mode_page(mode_pages, 0x28,
7455 				      sizeof(struct ipr_mode_page28));
7456 
7457 	entry_length = mode_page->entry_length;
7458 
7459 	bus = mode_page->bus;
7460 
7461 	for (i = 0; i < mode_page->num_entries; i++) {
7462 		if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
7463 			dev_err(&ioa_cfg->pdev->dev,
7464 				"Term power is absent on scsi bus %d\n",
7465 				bus->res_addr.bus);
7466 		}
7467 
7468 		bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
7469 	}
7470 }
7471 
7472 /**
7473  * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7474  * @ioa_cfg:	ioa config struct
7475  *
7476  * Looks through the config table checking for SES devices. If
7477  * the SES device is in the SES table indicating a maximum SCSI
7478  * bus speed, the speed is limited for the bus.
7479  *
7480  * Return value:
7481  * 	none
7482  **/
7483 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
7484 {
7485 	u32 max_xfer_rate;
7486 	int i;
7487 
7488 	for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
7489 		max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
7490 						       ioa_cfg->bus_attr[i].bus_width);
7491 
7492 		if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
7493 			ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
7494 	}
7495 }
7496 
7497 /**
7498  * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7499  * @ioa_cfg:	ioa config struct
7500  * @mode_pages:	mode page 28 buffer
7501  *
7502  * Updates mode page 28 based on driver configuration
7503  *
7504  * Return value:
7505  * 	none
7506  **/
7507 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
7508 					  struct ipr_mode_pages *mode_pages)
7509 {
7510 	int i, entry_length;
7511 	struct ipr_dev_bus_entry *bus;
7512 	struct ipr_bus_attributes *bus_attr;
7513 	struct ipr_mode_page28 *mode_page;
7514 
7515 	mode_page = ipr_get_mode_page(mode_pages, 0x28,
7516 				      sizeof(struct ipr_mode_page28));
7517 
7518 	entry_length = mode_page->entry_length;
7519 
7520 	/* Loop for each device bus entry */
7521 	for (i = 0, bus = mode_page->bus;
7522 	     i < mode_page->num_entries;
7523 	     i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
7524 		if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
7525 			dev_err(&ioa_cfg->pdev->dev,
7526 				"Invalid resource address reported: 0x%08X\n",
7527 				IPR_GET_PHYS_LOC(bus->res_addr));
7528 			continue;
7529 		}
7530 
7531 		bus_attr = &ioa_cfg->bus_attr[i];
7532 		bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
7533 		bus->bus_width = bus_attr->bus_width;
7534 		bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
7535 		bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
7536 		if (bus_attr->qas_enabled)
7537 			bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
7538 		else
7539 			bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
7540 	}
7541 }
7542 
7543 /**
7544  * ipr_build_mode_select - Build a mode select command
7545  * @ipr_cmd:	ipr command struct
7546  * @res_handle:	resource handle to send command to
7547  * @parm:		Byte 2 of Mode Sense command
7548  * @dma_addr:	DMA buffer address
7549  * @xfer_len:	data transfer length
7550  *
7551  * Return value:
7552  * 	none
7553  **/
7554 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
7555 				  __be32 res_handle, u8 parm,
7556 				  dma_addr_t dma_addr, u8 xfer_len)
7557 {
7558 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7559 
7560 	ioarcb->res_handle = res_handle;
7561 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7562 	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7563 	ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
7564 	ioarcb->cmd_pkt.cdb[1] = parm;
7565 	ioarcb->cmd_pkt.cdb[4] = xfer_len;
7566 
7567 	ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
7568 }
7569 
7570 /**
7571  * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7572  * @ipr_cmd:	ipr command struct
7573  *
7574  * This function sets up the SCSI bus attributes and sends
7575  * a Mode Select for Page 28 to activate them.
7576  *
7577  * Return value:
7578  * 	IPR_RC_JOB_RETURN
7579  **/
7580 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
7581 {
7582 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7583 	struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7584 	int length;
7585 
7586 	ENTER;
7587 	ipr_scsi_bus_speed_limit(ioa_cfg);
7588 	ipr_check_term_power(ioa_cfg, mode_pages);
7589 	ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
7590 	length = mode_pages->hdr.length + 1;
7591 	mode_pages->hdr.length = 0;
7592 
7593 	ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7594 			      ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7595 			      length);
7596 
7597 	ipr_cmd->job_step = ipr_set_supported_devs;
7598 	ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7599 				    struct ipr_resource_entry, queue);
7600 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7601 
7602 	LEAVE;
7603 	return IPR_RC_JOB_RETURN;
7604 }
7605 
7606 /**
7607  * ipr_build_mode_sense - Builds a mode sense command
7608  * @ipr_cmd:	ipr command struct
7609  * @res_handle:		resource entry struct
7610  * @parm:		Byte 2 of mode sense command
7611  * @dma_addr:	DMA address of mode sense buffer
7612  * @xfer_len:	Size of DMA buffer
7613  *
7614  * Return value:
7615  * 	none
7616  **/
7617 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
7618 				 __be32 res_handle,
7619 				 u8 parm, dma_addr_t dma_addr, u8 xfer_len)
7620 {
7621 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7622 
7623 	ioarcb->res_handle = res_handle;
7624 	ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
7625 	ioarcb->cmd_pkt.cdb[2] = parm;
7626 	ioarcb->cmd_pkt.cdb[4] = xfer_len;
7627 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7628 
7629 	ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
7630 }
7631 
7632 /**
7633  * ipr_reset_cmd_failed - Handle failure of IOA reset command
7634  * @ipr_cmd:	ipr command struct
7635  *
7636  * This function handles the failure of an IOA bringup command.
7637  *
7638  * Return value:
7639  * 	IPR_RC_JOB_RETURN
7640  **/
7641 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
7642 {
7643 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7644 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7645 
7646 	dev_err(&ioa_cfg->pdev->dev,
7647 		"0x%02X failed with IOASC: 0x%08X\n",
7648 		ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
7649 
7650 	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
7651 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7652 	return IPR_RC_JOB_RETURN;
7653 }
7654 
7655 /**
7656  * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7657  * @ipr_cmd:	ipr command struct
7658  *
7659  * This function handles the failure of a Mode Sense to the IOAFP.
7660  * Some adapters do not handle all mode pages.
7661  *
7662  * Return value:
7663  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7664  **/
7665 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
7666 {
7667 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7668 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7669 
7670 	if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7671 		ipr_cmd->job_step = ipr_set_supported_devs;
7672 		ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7673 					    struct ipr_resource_entry, queue);
7674 		return IPR_RC_JOB_CONTINUE;
7675 	}
7676 
7677 	return ipr_reset_cmd_failed(ipr_cmd);
7678 }
7679 
7680 /**
7681  * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7682  * @ipr_cmd:	ipr command struct
7683  *
7684  * This function send a Page 28 mode sense to the IOA to
7685  * retrieve SCSI bus attributes.
7686  *
7687  * Return value:
7688  * 	IPR_RC_JOB_RETURN
7689  **/
7690 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
7691 {
7692 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7693 
7694 	ENTER;
7695 	ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7696 			     0x28, ioa_cfg->vpd_cbs_dma +
7697 			     offsetof(struct ipr_misc_cbs, mode_pages),
7698 			     sizeof(struct ipr_mode_pages));
7699 
7700 	ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
7701 	ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
7702 
7703 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7704 
7705 	LEAVE;
7706 	return IPR_RC_JOB_RETURN;
7707 }
7708 
7709 /**
7710  * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7711  * @ipr_cmd:	ipr command struct
7712  *
7713  * This function enables dual IOA RAID support if possible.
7714  *
7715  * Return value:
7716  * 	IPR_RC_JOB_RETURN
7717  **/
7718 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
7719 {
7720 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7721 	struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7722 	struct ipr_mode_page24 *mode_page;
7723 	int length;
7724 
7725 	ENTER;
7726 	mode_page = ipr_get_mode_page(mode_pages, 0x24,
7727 				      sizeof(struct ipr_mode_page24));
7728 
7729 	if (mode_page)
7730 		mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
7731 
7732 	length = mode_pages->hdr.length + 1;
7733 	mode_pages->hdr.length = 0;
7734 
7735 	ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7736 			      ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7737 			      length);
7738 
7739 	ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7740 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7741 
7742 	LEAVE;
7743 	return IPR_RC_JOB_RETURN;
7744 }
7745 
7746 /**
7747  * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7748  * @ipr_cmd:	ipr command struct
7749  *
7750  * This function handles the failure of a Mode Sense to the IOAFP.
7751  * Some adapters do not handle all mode pages.
7752  *
7753  * Return value:
7754  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7755  **/
7756 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
7757 {
7758 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7759 
7760 	if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7761 		ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7762 		return IPR_RC_JOB_CONTINUE;
7763 	}
7764 
7765 	return ipr_reset_cmd_failed(ipr_cmd);
7766 }
7767 
7768 /**
7769  * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7770  * @ipr_cmd:	ipr command struct
7771  *
7772  * This function send a mode sense to the IOA to retrieve
7773  * the IOA Advanced Function Control mode page.
7774  *
7775  * Return value:
7776  * 	IPR_RC_JOB_RETURN
7777  **/
7778 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
7779 {
7780 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7781 
7782 	ENTER;
7783 	ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7784 			     0x24, ioa_cfg->vpd_cbs_dma +
7785 			     offsetof(struct ipr_misc_cbs, mode_pages),
7786 			     sizeof(struct ipr_mode_pages));
7787 
7788 	ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
7789 	ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
7790 
7791 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7792 
7793 	LEAVE;
7794 	return IPR_RC_JOB_RETURN;
7795 }
7796 
7797 /**
7798  * ipr_init_res_table - Initialize the resource table
7799  * @ipr_cmd:	ipr command struct
7800  *
7801  * This function looks through the existing resource table, comparing
7802  * it with the config table. This function will take care of old/new
7803  * devices and schedule adding/removing them from the mid-layer
7804  * as appropriate.
7805  *
7806  * Return value:
7807  * 	IPR_RC_JOB_CONTINUE
7808  **/
7809 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
7810 {
7811 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7812 	struct ipr_resource_entry *res, *temp;
7813 	struct ipr_config_table_entry_wrapper cfgtew;
7814 	int entries, found, flag, i;
7815 	LIST_HEAD(old_res);
7816 
7817 	ENTER;
7818 	if (ioa_cfg->sis64)
7819 		flag = ioa_cfg->u.cfg_table64->hdr64.flags;
7820 	else
7821 		flag = ioa_cfg->u.cfg_table->hdr.flags;
7822 
7823 	if (flag & IPR_UCODE_DOWNLOAD_REQ)
7824 		dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
7825 
7826 	list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
7827 		list_move_tail(&res->queue, &old_res);
7828 
7829 	if (ioa_cfg->sis64)
7830 		entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
7831 	else
7832 		entries = ioa_cfg->u.cfg_table->hdr.num_entries;
7833 
7834 	for (i = 0; i < entries; i++) {
7835 		if (ioa_cfg->sis64)
7836 			cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
7837 		else
7838 			cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
7839 		found = 0;
7840 
7841 		list_for_each_entry_safe(res, temp, &old_res, queue) {
7842 			if (ipr_is_same_device(res, &cfgtew)) {
7843 				list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7844 				found = 1;
7845 				break;
7846 			}
7847 		}
7848 
7849 		if (!found) {
7850 			if (list_empty(&ioa_cfg->free_res_q)) {
7851 				dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
7852 				break;
7853 			}
7854 
7855 			found = 1;
7856 			res = list_entry(ioa_cfg->free_res_q.next,
7857 					 struct ipr_resource_entry, queue);
7858 			list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7859 			ipr_init_res_entry(res, &cfgtew);
7860 			res->add_to_ml = 1;
7861 		} else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res)))
7862 			res->sdev->allow_restart = 1;
7863 
7864 		if (found)
7865 			ipr_update_res_entry(res, &cfgtew);
7866 	}
7867 
7868 	list_for_each_entry_safe(res, temp, &old_res, queue) {
7869 		if (res->sdev) {
7870 			res->del_from_ml = 1;
7871 			res->res_handle = IPR_INVALID_RES_HANDLE;
7872 			list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7873 		}
7874 	}
7875 
7876 	list_for_each_entry_safe(res, temp, &old_res, queue) {
7877 		ipr_clear_res_target(res);
7878 		list_move_tail(&res->queue, &ioa_cfg->free_res_q);
7879 	}
7880 
7881 	if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
7882 		ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
7883 	else
7884 		ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7885 
7886 	LEAVE;
7887 	return IPR_RC_JOB_CONTINUE;
7888 }
7889 
7890 /**
7891  * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7892  * @ipr_cmd:	ipr command struct
7893  *
7894  * This function sends a Query IOA Configuration command
7895  * to the adapter to retrieve the IOA configuration table.
7896  *
7897  * Return value:
7898  * 	IPR_RC_JOB_RETURN
7899  **/
7900 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
7901 {
7902 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7903 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7904 	struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
7905 	struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
7906 
7907 	ENTER;
7908 	if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
7909 		ioa_cfg->dual_raid = 1;
7910 	dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
7911 		 ucode_vpd->major_release, ucode_vpd->card_type,
7912 		 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
7913 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7914 	ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7915 
7916 	ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
7917 	ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
7918 	ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
7919 	ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
7920 
7921 	ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
7922 		       IPR_IOADL_FLAGS_READ_LAST);
7923 
7924 	ipr_cmd->job_step = ipr_init_res_table;
7925 
7926 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7927 
7928 	LEAVE;
7929 	return IPR_RC_JOB_RETURN;
7930 }
7931 
7932 static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd)
7933 {
7934 	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7935 
7936 	if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT)
7937 		return IPR_RC_JOB_CONTINUE;
7938 
7939 	return ipr_reset_cmd_failed(ipr_cmd);
7940 }
7941 
7942 static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd,
7943 					 __be32 res_handle, u8 sa_code)
7944 {
7945 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7946 
7947 	ioarcb->res_handle = res_handle;
7948 	ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION;
7949 	ioarcb->cmd_pkt.cdb[1] = sa_code;
7950 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7951 }
7952 
7953 /**
7954  * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7955  * action
7956  * @ipr_cmd:	ipr command struct
7957  *
7958  * Return value:
7959  *	none
7960  **/
7961 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd)
7962 {
7963 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7964 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7965 	struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
7966 
7967 	ENTER;
7968 
7969 	ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
7970 
7971 	if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) {
7972 		ipr_build_ioa_service_action(ipr_cmd,
7973 					     cpu_to_be32(IPR_IOA_RES_HANDLE),
7974 					     IPR_IOA_SA_CHANGE_CACHE_PARAMS);
7975 
7976 		ioarcb->cmd_pkt.cdb[2] = 0x40;
7977 
7978 		ipr_cmd->job_step_failed = ipr_ioa_service_action_failed;
7979 		ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7980 			   IPR_SET_SUP_DEVICE_TIMEOUT);
7981 
7982 		LEAVE;
7983 		return IPR_RC_JOB_RETURN;
7984 	}
7985 
7986 	LEAVE;
7987 	return IPR_RC_JOB_CONTINUE;
7988 }
7989 
7990 /**
7991  * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7992  * @ipr_cmd:	ipr command struct
7993  * @flags:	flags to send
7994  * @page:	page to inquire
7995  * @dma_addr:	DMA address
7996  * @xfer_len:	transfer data length
7997  *
7998  * This utility function sends an inquiry to the adapter.
7999  *
8000  * Return value:
8001  * 	none
8002  **/
8003 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
8004 			      dma_addr_t dma_addr, u8 xfer_len)
8005 {
8006 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8007 
8008 	ENTER;
8009 	ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
8010 	ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8011 
8012 	ioarcb->cmd_pkt.cdb[0] = INQUIRY;
8013 	ioarcb->cmd_pkt.cdb[1] = flags;
8014 	ioarcb->cmd_pkt.cdb[2] = page;
8015 	ioarcb->cmd_pkt.cdb[4] = xfer_len;
8016 
8017 	ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
8018 
8019 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
8020 	LEAVE;
8021 }
8022 
8023 /**
8024  * ipr_inquiry_page_supported - Is the given inquiry page supported
8025  * @page0:		inquiry page 0 buffer
8026  * @page:		page code.
8027  *
8028  * This function determines if the specified inquiry page is supported.
8029  *
8030  * Return value:
8031  *	1 if page is supported / 0 if not
8032  **/
8033 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
8034 {
8035 	int i;
8036 
8037 	for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
8038 		if (page0->page[i] == page)
8039 			return 1;
8040 
8041 	return 0;
8042 }
8043 
8044 /**
8045  * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
8046  * @ipr_cmd:	ipr command struct
8047  *
8048  * This function sends a Page 0xC4 inquiry to the adapter
8049  * to retrieve software VPD information.
8050  *
8051  * Return value:
8052  *	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8053  **/
8054 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd)
8055 {
8056 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8057 	struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8058 	struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
8059 
8060 	ENTER;
8061 	ipr_cmd->job_step = ipr_ioafp_set_caching_parameters;
8062 	memset(pageC4, 0, sizeof(*pageC4));
8063 
8064 	if (ipr_inquiry_page_supported(page0, 0xC4)) {
8065 		ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4,
8066 				  (ioa_cfg->vpd_cbs_dma
8067 				   + offsetof(struct ipr_misc_cbs,
8068 					      pageC4_data)),
8069 				  sizeof(struct ipr_inquiry_pageC4));
8070 		return IPR_RC_JOB_RETURN;
8071 	}
8072 
8073 	LEAVE;
8074 	return IPR_RC_JOB_CONTINUE;
8075 }
8076 
8077 /**
8078  * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
8079  * @ipr_cmd:	ipr command struct
8080  *
8081  * This function sends a Page 0xD0 inquiry to the adapter
8082  * to retrieve adapter capabilities.
8083  *
8084  * Return value:
8085  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8086  **/
8087 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
8088 {
8089 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8090 	struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8091 	struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
8092 
8093 	ENTER;
8094 	ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry;
8095 	memset(cap, 0, sizeof(*cap));
8096 
8097 	if (ipr_inquiry_page_supported(page0, 0xD0)) {
8098 		ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
8099 				  ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
8100 				  sizeof(struct ipr_inquiry_cap));
8101 		return IPR_RC_JOB_RETURN;
8102 	}
8103 
8104 	LEAVE;
8105 	return IPR_RC_JOB_CONTINUE;
8106 }
8107 
8108 /**
8109  * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
8110  * @ipr_cmd:	ipr command struct
8111  *
8112  * This function sends a Page 3 inquiry to the adapter
8113  * to retrieve software VPD information.
8114  *
8115  * Return value:
8116  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8117  **/
8118 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
8119 {
8120 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8121 
8122 	ENTER;
8123 
8124 	ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
8125 
8126 	ipr_ioafp_inquiry(ipr_cmd, 1, 3,
8127 			  ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
8128 			  sizeof(struct ipr_inquiry_page3));
8129 
8130 	LEAVE;
8131 	return IPR_RC_JOB_RETURN;
8132 }
8133 
8134 /**
8135  * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
8136  * @ipr_cmd:	ipr command struct
8137  *
8138  * This function sends a Page 0 inquiry to the adapter
8139  * to retrieve supported inquiry pages.
8140  *
8141  * Return value:
8142  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8143  **/
8144 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
8145 {
8146 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8147 	char type[5];
8148 
8149 	ENTER;
8150 
8151 	/* Grab the type out of the VPD and store it away */
8152 	memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
8153 	type[4] = '\0';
8154 	ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
8155 
8156 	if (ipr_invalid_adapter(ioa_cfg)) {
8157 		dev_err(&ioa_cfg->pdev->dev,
8158 			"Adapter not supported in this hardware configuration.\n");
8159 
8160 		if (!ipr_testmode) {
8161 			ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
8162 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
8163 			list_add_tail(&ipr_cmd->queue,
8164 					&ioa_cfg->hrrq->hrrq_free_q);
8165 			return IPR_RC_JOB_RETURN;
8166 		}
8167 	}
8168 
8169 	ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
8170 
8171 	ipr_ioafp_inquiry(ipr_cmd, 1, 0,
8172 			  ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
8173 			  sizeof(struct ipr_inquiry_page0));
8174 
8175 	LEAVE;
8176 	return IPR_RC_JOB_RETURN;
8177 }
8178 
8179 /**
8180  * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
8181  * @ipr_cmd:	ipr command struct
8182  *
8183  * This function sends a standard inquiry to the adapter.
8184  *
8185  * Return value:
8186  * 	IPR_RC_JOB_RETURN
8187  **/
8188 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
8189 {
8190 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8191 
8192 	ENTER;
8193 	ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
8194 
8195 	ipr_ioafp_inquiry(ipr_cmd, 0, 0,
8196 			  ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
8197 			  sizeof(struct ipr_ioa_vpd));
8198 
8199 	LEAVE;
8200 	return IPR_RC_JOB_RETURN;
8201 }
8202 
8203 /**
8204  * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
8205  * @ipr_cmd:	ipr command struct
8206  *
8207  * This function send an Identify Host Request Response Queue
8208  * command to establish the HRRQ with the adapter.
8209  *
8210  * Return value:
8211  * 	IPR_RC_JOB_RETURN
8212  **/
8213 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
8214 {
8215 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8216 	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8217 	struct ipr_hrr_queue *hrrq;
8218 
8219 	ENTER;
8220 	ipr_cmd->job_step = ipr_ioafp_std_inquiry;
8221 	if (ioa_cfg->identify_hrrq_index == 0)
8222 		dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
8223 
8224 	if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) {
8225 		hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index];
8226 
8227 		ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
8228 		ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8229 
8230 		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
8231 		if (ioa_cfg->sis64)
8232 			ioarcb->cmd_pkt.cdb[1] = 0x1;
8233 
8234 		if (ioa_cfg->nvectors == 1)
8235 			ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE;
8236 		else
8237 			ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE;
8238 
8239 		ioarcb->cmd_pkt.cdb[2] =
8240 			((u64) hrrq->host_rrq_dma >> 24) & 0xff;
8241 		ioarcb->cmd_pkt.cdb[3] =
8242 			((u64) hrrq->host_rrq_dma >> 16) & 0xff;
8243 		ioarcb->cmd_pkt.cdb[4] =
8244 			((u64) hrrq->host_rrq_dma >> 8) & 0xff;
8245 		ioarcb->cmd_pkt.cdb[5] =
8246 			((u64) hrrq->host_rrq_dma) & 0xff;
8247 		ioarcb->cmd_pkt.cdb[7] =
8248 			((sizeof(u32) * hrrq->size) >> 8) & 0xff;
8249 		ioarcb->cmd_pkt.cdb[8] =
8250 			(sizeof(u32) * hrrq->size) & 0xff;
8251 
8252 		if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8253 			ioarcb->cmd_pkt.cdb[9] =
8254 					ioa_cfg->identify_hrrq_index;
8255 
8256 		if (ioa_cfg->sis64) {
8257 			ioarcb->cmd_pkt.cdb[10] =
8258 				((u64) hrrq->host_rrq_dma >> 56) & 0xff;
8259 			ioarcb->cmd_pkt.cdb[11] =
8260 				((u64) hrrq->host_rrq_dma >> 48) & 0xff;
8261 			ioarcb->cmd_pkt.cdb[12] =
8262 				((u64) hrrq->host_rrq_dma >> 40) & 0xff;
8263 			ioarcb->cmd_pkt.cdb[13] =
8264 				((u64) hrrq->host_rrq_dma >> 32) & 0xff;
8265 		}
8266 
8267 		if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8268 			ioarcb->cmd_pkt.cdb[14] =
8269 					ioa_cfg->identify_hrrq_index;
8270 
8271 		ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
8272 			   IPR_INTERNAL_TIMEOUT);
8273 
8274 		if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num)
8275 			ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8276 
8277 		LEAVE;
8278 		return IPR_RC_JOB_RETURN;
8279 	}
8280 
8281 	LEAVE;
8282 	return IPR_RC_JOB_CONTINUE;
8283 }
8284 
8285 /**
8286  * ipr_reset_timer_done - Adapter reset timer function
8287  * @t: Timer context used to fetch ipr command struct
8288  *
8289  * Description: This function is used in adapter reset processing
8290  * for timing events. If the reset_cmd pointer in the IOA
8291  * config struct is not this adapter's we are doing nested
8292  * resets and fail_all_ops will take care of freeing the
8293  * command block.
8294  *
8295  * Return value:
8296  * 	none
8297  **/
8298 static void ipr_reset_timer_done(struct timer_list *t)
8299 {
8300 	struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
8301 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8302 	unsigned long lock_flags = 0;
8303 
8304 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8305 
8306 	if (ioa_cfg->reset_cmd == ipr_cmd) {
8307 		list_del(&ipr_cmd->queue);
8308 		ipr_cmd->done(ipr_cmd);
8309 	}
8310 
8311 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8312 }
8313 
8314 /**
8315  * ipr_reset_start_timer - Start a timer for adapter reset job
8316  * @ipr_cmd:	ipr command struct
8317  * @timeout:	timeout value
8318  *
8319  * Description: This function is used in adapter reset processing
8320  * for timing events. If the reset_cmd pointer in the IOA
8321  * config struct is not this adapter's we are doing nested
8322  * resets and fail_all_ops will take care of freeing the
8323  * command block.
8324  *
8325  * Return value:
8326  * 	none
8327  **/
8328 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
8329 				  unsigned long timeout)
8330 {
8331 
8332 	ENTER;
8333 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8334 	ipr_cmd->done = ipr_reset_ioa_job;
8335 
8336 	ipr_cmd->timer.expires = jiffies + timeout;
8337 	ipr_cmd->timer.function = ipr_reset_timer_done;
8338 	add_timer(&ipr_cmd->timer);
8339 }
8340 
8341 /**
8342  * ipr_init_ioa_mem - Initialize ioa_cfg control block
8343  * @ioa_cfg:	ioa cfg struct
8344  *
8345  * Return value:
8346  * 	nothing
8347  **/
8348 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
8349 {
8350 	struct ipr_hrr_queue *hrrq;
8351 
8352 	for_each_hrrq(hrrq, ioa_cfg) {
8353 		spin_lock(&hrrq->_lock);
8354 		memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size);
8355 
8356 		/* Initialize Host RRQ pointers */
8357 		hrrq->hrrq_start = hrrq->host_rrq;
8358 		hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1];
8359 		hrrq->hrrq_curr = hrrq->hrrq_start;
8360 		hrrq->toggle_bit = 1;
8361 		spin_unlock(&hrrq->_lock);
8362 	}
8363 	wmb();
8364 
8365 	ioa_cfg->identify_hrrq_index = 0;
8366 	if (ioa_cfg->hrrq_num == 1)
8367 		atomic_set(&ioa_cfg->hrrq_index, 0);
8368 	else
8369 		atomic_set(&ioa_cfg->hrrq_index, 1);
8370 
8371 	/* Zero out config table */
8372 	memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
8373 }
8374 
8375 /**
8376  * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8377  * @ipr_cmd:	ipr command struct
8378  *
8379  * Return value:
8380  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8381  **/
8382 static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
8383 {
8384 	unsigned long stage, stage_time;
8385 	u32 feedback;
8386 	volatile u32 int_reg;
8387 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8388 	u64 maskval = 0;
8389 
8390 	feedback = readl(ioa_cfg->regs.init_feedback_reg);
8391 	stage = feedback & IPR_IPL_INIT_STAGE_MASK;
8392 	stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
8393 
8394 	ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
8395 
8396 	/* sanity check the stage_time value */
8397 	if (stage_time == 0)
8398 		stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
8399 	else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
8400 		stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
8401 	else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
8402 		stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
8403 
8404 	if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
8405 		writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
8406 		int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8407 		stage_time = ioa_cfg->transop_timeout;
8408 		ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8409 	} else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
8410 		int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8411 		if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8412 			ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8413 			maskval = IPR_PCII_IPL_STAGE_CHANGE;
8414 			maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
8415 			writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
8416 			int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8417 			return IPR_RC_JOB_CONTINUE;
8418 		}
8419 	}
8420 
8421 	ipr_cmd->timer.expires = jiffies + stage_time * HZ;
8422 	ipr_cmd->timer.function = ipr_oper_timeout;
8423 	ipr_cmd->done = ipr_reset_ioa_job;
8424 	add_timer(&ipr_cmd->timer);
8425 
8426 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8427 
8428 	return IPR_RC_JOB_RETURN;
8429 }
8430 
8431 /**
8432  * ipr_reset_enable_ioa - Enable the IOA following a reset.
8433  * @ipr_cmd:	ipr command struct
8434  *
8435  * This function reinitializes some control blocks and
8436  * enables destructive diagnostics on the adapter.
8437  *
8438  * Return value:
8439  * 	IPR_RC_JOB_RETURN
8440  **/
8441 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
8442 {
8443 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8444 	volatile u32 int_reg;
8445 	volatile u64 maskval;
8446 	int i;
8447 
8448 	ENTER;
8449 	ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8450 	ipr_init_ioa_mem(ioa_cfg);
8451 
8452 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
8453 		spin_lock(&ioa_cfg->hrrq[i]._lock);
8454 		ioa_cfg->hrrq[i].allow_interrupts = 1;
8455 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
8456 	}
8457 	if (ioa_cfg->sis64) {
8458 		/* Set the adapter to the correct endian mode. */
8459 		writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8460 		int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8461 	}
8462 
8463 	int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8464 
8465 	if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8466 		writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
8467 		       ioa_cfg->regs.clr_interrupt_mask_reg32);
8468 		int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8469 		return IPR_RC_JOB_CONTINUE;
8470 	}
8471 
8472 	/* Enable destructive diagnostics on IOA */
8473 	writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
8474 
8475 	if (ioa_cfg->sis64) {
8476 		maskval = IPR_PCII_IPL_STAGE_CHANGE;
8477 		maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
8478 		writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
8479 	} else
8480 		writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
8481 
8482 	int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8483 
8484 	dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
8485 
8486 	if (ioa_cfg->sis64) {
8487 		ipr_cmd->job_step = ipr_reset_next_stage;
8488 		return IPR_RC_JOB_CONTINUE;
8489 	}
8490 
8491 	ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
8492 	ipr_cmd->timer.function = ipr_oper_timeout;
8493 	ipr_cmd->done = ipr_reset_ioa_job;
8494 	add_timer(&ipr_cmd->timer);
8495 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8496 
8497 	LEAVE;
8498 	return IPR_RC_JOB_RETURN;
8499 }
8500 
8501 /**
8502  * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8503  * @ipr_cmd:	ipr command struct
8504  *
8505  * This function is invoked when an adapter dump has run out
8506  * of processing time.
8507  *
8508  * Return value:
8509  * 	IPR_RC_JOB_CONTINUE
8510  **/
8511 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
8512 {
8513 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8514 
8515 	if (ioa_cfg->sdt_state == GET_DUMP)
8516 		ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8517 	else if (ioa_cfg->sdt_state == READ_DUMP)
8518 		ioa_cfg->sdt_state = ABORT_DUMP;
8519 
8520 	ioa_cfg->dump_timeout = 1;
8521 	ipr_cmd->job_step = ipr_reset_alert;
8522 
8523 	return IPR_RC_JOB_CONTINUE;
8524 }
8525 
8526 /**
8527  * ipr_unit_check_no_data - Log a unit check/no data error log
8528  * @ioa_cfg:		ioa config struct
8529  *
8530  * Logs an error indicating the adapter unit checked, but for some
8531  * reason, we were unable to fetch the unit check buffer.
8532  *
8533  * Return value:
8534  * 	nothing
8535  **/
8536 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
8537 {
8538 	ioa_cfg->errors_logged++;
8539 	dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
8540 }
8541 
8542 /**
8543  * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8544  * @ioa_cfg:		ioa config struct
8545  *
8546  * Fetches the unit check buffer from the adapter by clocking the data
8547  * through the mailbox register.
8548  *
8549  * Return value:
8550  * 	nothing
8551  **/
8552 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
8553 {
8554 	unsigned long mailbox;
8555 	struct ipr_hostrcb *hostrcb;
8556 	struct ipr_uc_sdt sdt;
8557 	int rc, length;
8558 	u32 ioasc;
8559 
8560 	mailbox = readl(ioa_cfg->ioa_mailbox);
8561 
8562 	if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
8563 		ipr_unit_check_no_data(ioa_cfg);
8564 		return;
8565 	}
8566 
8567 	memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
8568 	rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
8569 					(sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
8570 
8571 	if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
8572 	    ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
8573 	    (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
8574 		ipr_unit_check_no_data(ioa_cfg);
8575 		return;
8576 	}
8577 
8578 	/* Find length of the first sdt entry (UC buffer) */
8579 	if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
8580 		length = be32_to_cpu(sdt.entry[0].end_token);
8581 	else
8582 		length = (be32_to_cpu(sdt.entry[0].end_token) -
8583 			  be32_to_cpu(sdt.entry[0].start_token)) &
8584 			  IPR_FMT2_MBX_ADDR_MASK;
8585 
8586 	hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
8587 			     struct ipr_hostrcb, queue);
8588 	list_del_init(&hostrcb->queue);
8589 	memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
8590 
8591 	rc = ipr_get_ldump_data_section(ioa_cfg,
8592 					be32_to_cpu(sdt.entry[0].start_token),
8593 					(__be32 *)&hostrcb->hcam,
8594 					min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
8595 
8596 	if (!rc) {
8597 		ipr_handle_log_data(ioa_cfg, hostrcb);
8598 		ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
8599 		if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
8600 		    ioa_cfg->sdt_state == GET_DUMP)
8601 			ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8602 	} else
8603 		ipr_unit_check_no_data(ioa_cfg);
8604 
8605 	list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
8606 }
8607 
8608 /**
8609  * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8610  * @ipr_cmd:	ipr command struct
8611  *
8612  * Description: This function will call to get the unit check buffer.
8613  *
8614  * Return value:
8615  *	IPR_RC_JOB_RETURN
8616  **/
8617 static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
8618 {
8619 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8620 
8621 	ENTER;
8622 	ioa_cfg->ioa_unit_checked = 0;
8623 	ipr_get_unit_check_buffer(ioa_cfg);
8624 	ipr_cmd->job_step = ipr_reset_alert;
8625 	ipr_reset_start_timer(ipr_cmd, 0);
8626 
8627 	LEAVE;
8628 	return IPR_RC_JOB_RETURN;
8629 }
8630 
8631 static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd)
8632 {
8633 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8634 
8635 	ENTER;
8636 
8637 	if (ioa_cfg->sdt_state != GET_DUMP)
8638 		return IPR_RC_JOB_RETURN;
8639 
8640 	if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left ||
8641 	    (readl(ioa_cfg->regs.sense_interrupt_reg) &
8642 	     IPR_PCII_MAILBOX_STABLE)) {
8643 
8644 		if (!ipr_cmd->u.time_left)
8645 			dev_err(&ioa_cfg->pdev->dev,
8646 				"Timed out waiting for Mailbox register.\n");
8647 
8648 		ioa_cfg->sdt_state = READ_DUMP;
8649 		ioa_cfg->dump_timeout = 0;
8650 		if (ioa_cfg->sis64)
8651 			ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
8652 		else
8653 			ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
8654 		ipr_cmd->job_step = ipr_reset_wait_for_dump;
8655 		schedule_work(&ioa_cfg->work_q);
8656 
8657 	} else {
8658 		ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8659 		ipr_reset_start_timer(ipr_cmd,
8660 				      IPR_CHECK_FOR_RESET_TIMEOUT);
8661 	}
8662 
8663 	LEAVE;
8664 	return IPR_RC_JOB_RETURN;
8665 }
8666 
8667 /**
8668  * ipr_reset_restore_cfg_space - Restore PCI config space.
8669  * @ipr_cmd:	ipr command struct
8670  *
8671  * Description: This function restores the saved PCI config space of
8672  * the adapter, fails all outstanding ops back to the callers, and
8673  * fetches the dump/unit check if applicable to this reset.
8674  *
8675  * Return value:
8676  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8677  **/
8678 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
8679 {
8680 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8681 
8682 	ENTER;
8683 	ioa_cfg->pdev->state_saved = true;
8684 	pci_restore_state(ioa_cfg->pdev);
8685 
8686 	if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
8687 		ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8688 		return IPR_RC_JOB_CONTINUE;
8689 	}
8690 
8691 	ipr_fail_all_ops(ioa_cfg);
8692 
8693 	if (ioa_cfg->sis64) {
8694 		/* Set the adapter to the correct endian mode. */
8695 		writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8696 		readl(ioa_cfg->regs.endian_swap_reg);
8697 	}
8698 
8699 	if (ioa_cfg->ioa_unit_checked) {
8700 		if (ioa_cfg->sis64) {
8701 			ipr_cmd->job_step = ipr_reset_get_unit_check_job;
8702 			ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
8703 			return IPR_RC_JOB_RETURN;
8704 		} else {
8705 			ioa_cfg->ioa_unit_checked = 0;
8706 			ipr_get_unit_check_buffer(ioa_cfg);
8707 			ipr_cmd->job_step = ipr_reset_alert;
8708 			ipr_reset_start_timer(ipr_cmd, 0);
8709 			return IPR_RC_JOB_RETURN;
8710 		}
8711 	}
8712 
8713 	if (ioa_cfg->in_ioa_bringdown) {
8714 		ipr_cmd->job_step = ipr_ioa_bringdown_done;
8715 	} else if (ioa_cfg->sdt_state == GET_DUMP) {
8716 		ipr_cmd->job_step = ipr_dump_mailbox_wait;
8717 		ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX;
8718 	} else {
8719 		ipr_cmd->job_step = ipr_reset_enable_ioa;
8720 	}
8721 
8722 	LEAVE;
8723 	return IPR_RC_JOB_CONTINUE;
8724 }
8725 
8726 /**
8727  * ipr_reset_bist_done - BIST has completed on the adapter.
8728  * @ipr_cmd:	ipr command struct
8729  *
8730  * Description: Unblock config space and resume the reset process.
8731  *
8732  * Return value:
8733  * 	IPR_RC_JOB_CONTINUE
8734  **/
8735 static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
8736 {
8737 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8738 
8739 	ENTER;
8740 	if (ioa_cfg->cfg_locked)
8741 		pci_cfg_access_unlock(ioa_cfg->pdev);
8742 	ioa_cfg->cfg_locked = 0;
8743 	ipr_cmd->job_step = ipr_reset_restore_cfg_space;
8744 	LEAVE;
8745 	return IPR_RC_JOB_CONTINUE;
8746 }
8747 
8748 /**
8749  * ipr_reset_start_bist - Run BIST on the adapter.
8750  * @ipr_cmd:	ipr command struct
8751  *
8752  * Description: This function runs BIST on the adapter, then delays 2 seconds.
8753  *
8754  * Return value:
8755  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8756  **/
8757 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
8758 {
8759 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8760 	int rc = PCIBIOS_SUCCESSFUL;
8761 
8762 	ENTER;
8763 	if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO)
8764 		writel(IPR_UPROCI_SIS64_START_BIST,
8765 		       ioa_cfg->regs.set_uproc_interrupt_reg32);
8766 	else
8767 		rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
8768 
8769 	if (rc == PCIBIOS_SUCCESSFUL) {
8770 		ipr_cmd->job_step = ipr_reset_bist_done;
8771 		ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8772 		rc = IPR_RC_JOB_RETURN;
8773 	} else {
8774 		if (ioa_cfg->cfg_locked)
8775 			pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev);
8776 		ioa_cfg->cfg_locked = 0;
8777 		ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8778 		rc = IPR_RC_JOB_CONTINUE;
8779 	}
8780 
8781 	LEAVE;
8782 	return rc;
8783 }
8784 
8785 /**
8786  * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8787  * @ipr_cmd:	ipr command struct
8788  *
8789  * Description: This clears PCI reset to the adapter and delays two seconds.
8790  *
8791  * Return value:
8792  * 	IPR_RC_JOB_RETURN
8793  **/
8794 static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
8795 {
8796 	ENTER;
8797 	ipr_cmd->job_step = ipr_reset_bist_done;
8798 	ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8799 	LEAVE;
8800 	return IPR_RC_JOB_RETURN;
8801 }
8802 
8803 /**
8804  * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8805  * @work:	work struct
8806  *
8807  * Description: This pulses warm reset to a slot.
8808  *
8809  **/
8810 static void ipr_reset_reset_work(struct work_struct *work)
8811 {
8812 	struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work);
8813 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8814 	struct pci_dev *pdev = ioa_cfg->pdev;
8815 	unsigned long lock_flags = 0;
8816 
8817 	ENTER;
8818 	pci_set_pcie_reset_state(pdev, pcie_warm_reset);
8819 	msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT));
8820 	pci_set_pcie_reset_state(pdev, pcie_deassert_reset);
8821 
8822 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8823 	if (ioa_cfg->reset_cmd == ipr_cmd)
8824 		ipr_reset_ioa_job(ipr_cmd);
8825 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8826 	LEAVE;
8827 }
8828 
8829 /**
8830  * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8831  * @ipr_cmd:	ipr command struct
8832  *
8833  * Description: This asserts PCI reset to the adapter.
8834  *
8835  * Return value:
8836  * 	IPR_RC_JOB_RETURN
8837  **/
8838 static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
8839 {
8840 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8841 
8842 	ENTER;
8843 	INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work);
8844 	queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work);
8845 	ipr_cmd->job_step = ipr_reset_slot_reset_done;
8846 	LEAVE;
8847 	return IPR_RC_JOB_RETURN;
8848 }
8849 
8850 /**
8851  * ipr_reset_block_config_access_wait - Wait for permission to block config access
8852  * @ipr_cmd:	ipr command struct
8853  *
8854  * Description: This attempts to block config access to the IOA.
8855  *
8856  * Return value:
8857  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8858  **/
8859 static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd)
8860 {
8861 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8862 	int rc = IPR_RC_JOB_CONTINUE;
8863 
8864 	if (pci_cfg_access_trylock(ioa_cfg->pdev)) {
8865 		ioa_cfg->cfg_locked = 1;
8866 		ipr_cmd->job_step = ioa_cfg->reset;
8867 	} else {
8868 		if (ipr_cmd->u.time_left) {
8869 			rc = IPR_RC_JOB_RETURN;
8870 			ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8871 			ipr_reset_start_timer(ipr_cmd,
8872 					      IPR_CHECK_FOR_RESET_TIMEOUT);
8873 		} else {
8874 			ipr_cmd->job_step = ioa_cfg->reset;
8875 			dev_err(&ioa_cfg->pdev->dev,
8876 				"Timed out waiting to lock config access. Resetting anyway.\n");
8877 		}
8878 	}
8879 
8880 	return rc;
8881 }
8882 
8883 /**
8884  * ipr_reset_block_config_access - Block config access to the IOA
8885  * @ipr_cmd:	ipr command struct
8886  *
8887  * Description: This attempts to block config access to the IOA
8888  *
8889  * Return value:
8890  * 	IPR_RC_JOB_CONTINUE
8891  **/
8892 static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd)
8893 {
8894 	ipr_cmd->ioa_cfg->cfg_locked = 0;
8895 	ipr_cmd->job_step = ipr_reset_block_config_access_wait;
8896 	ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8897 	return IPR_RC_JOB_CONTINUE;
8898 }
8899 
8900 /**
8901  * ipr_reset_allowed - Query whether or not IOA can be reset
8902  * @ioa_cfg:	ioa config struct
8903  *
8904  * Return value:
8905  * 	0 if reset not allowed / non-zero if reset is allowed
8906  **/
8907 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
8908 {
8909 	volatile u32 temp_reg;
8910 
8911 	temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
8912 	return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
8913 }
8914 
8915 /**
8916  * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8917  * @ipr_cmd:	ipr command struct
8918  *
8919  * Description: This function waits for adapter permission to run BIST,
8920  * then runs BIST. If the adapter does not give permission after a
8921  * reasonable time, we will reset the adapter anyway. The impact of
8922  * resetting the adapter without warning the adapter is the risk of
8923  * losing the persistent error log on the adapter. If the adapter is
8924  * reset while it is writing to the flash on the adapter, the flash
8925  * segment will have bad ECC and be zeroed.
8926  *
8927  * Return value:
8928  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8929  **/
8930 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
8931 {
8932 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8933 	int rc = IPR_RC_JOB_RETURN;
8934 
8935 	if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
8936 		ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8937 		ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8938 	} else {
8939 		ipr_cmd->job_step = ipr_reset_block_config_access;
8940 		rc = IPR_RC_JOB_CONTINUE;
8941 	}
8942 
8943 	return rc;
8944 }
8945 
8946 /**
8947  * ipr_reset_alert - Alert the adapter of a pending reset
8948  * @ipr_cmd:	ipr command struct
8949  *
8950  * Description: This function alerts the adapter that it will be reset.
8951  * If memory space is not currently enabled, proceed directly
8952  * to running BIST on the adapter. The timer must always be started
8953  * so we guarantee we do not run BIST from ipr_isr.
8954  *
8955  * Return value:
8956  * 	IPR_RC_JOB_RETURN
8957  **/
8958 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
8959 {
8960 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8961 	u16 cmd_reg;
8962 	int rc;
8963 
8964 	ENTER;
8965 	rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
8966 
8967 	if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
8968 		ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
8969 		writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
8970 		ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
8971 	} else {
8972 		ipr_cmd->job_step = ipr_reset_block_config_access;
8973 	}
8974 
8975 	ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8976 	ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8977 
8978 	LEAVE;
8979 	return IPR_RC_JOB_RETURN;
8980 }
8981 
8982 /**
8983  * ipr_reset_quiesce_done - Complete IOA disconnect
8984  * @ipr_cmd:	ipr command struct
8985  *
8986  * Description: Freeze the adapter to complete quiesce processing
8987  *
8988  * Return value:
8989  * 	IPR_RC_JOB_CONTINUE
8990  **/
8991 static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd)
8992 {
8993 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8994 
8995 	ENTER;
8996 	ipr_cmd->job_step = ipr_ioa_bringdown_done;
8997 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
8998 	LEAVE;
8999 	return IPR_RC_JOB_CONTINUE;
9000 }
9001 
9002 /**
9003  * ipr_reset_cancel_hcam_done - Check for outstanding commands
9004  * @ipr_cmd:	ipr command struct
9005  *
9006  * Description: Ensure nothing is outstanding to the IOA and
9007  *			proceed with IOA disconnect. Otherwise reset the IOA.
9008  *
9009  * Return value:
9010  * 	IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
9011  **/
9012 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd)
9013 {
9014 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9015 	struct ipr_cmnd *loop_cmd;
9016 	struct ipr_hrr_queue *hrrq;
9017 	int rc = IPR_RC_JOB_CONTINUE;
9018 	int count = 0;
9019 
9020 	ENTER;
9021 	ipr_cmd->job_step = ipr_reset_quiesce_done;
9022 
9023 	for_each_hrrq(hrrq, ioa_cfg) {
9024 		spin_lock(&hrrq->_lock);
9025 		list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) {
9026 			count++;
9027 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9028 			list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9029 			rc = IPR_RC_JOB_RETURN;
9030 			break;
9031 		}
9032 		spin_unlock(&hrrq->_lock);
9033 
9034 		if (count)
9035 			break;
9036 	}
9037 
9038 	LEAVE;
9039 	return rc;
9040 }
9041 
9042 /**
9043  * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
9044  * @ipr_cmd:	ipr command struct
9045  *
9046  * Description: Cancel any oustanding HCAMs to the IOA.
9047  *
9048  * Return value:
9049  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9050  **/
9051 static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd)
9052 {
9053 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9054 	int rc = IPR_RC_JOB_CONTINUE;
9055 	struct ipr_cmd_pkt *cmd_pkt;
9056 	struct ipr_cmnd *hcam_cmd;
9057 	struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ];
9058 
9059 	ENTER;
9060 	ipr_cmd->job_step = ipr_reset_cancel_hcam_done;
9061 
9062 	if (!hrrq->ioa_is_dead) {
9063 		if (!list_empty(&ioa_cfg->hostrcb_pending_q)) {
9064 			list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) {
9065 				if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC)
9066 					continue;
9067 
9068 				ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9069 				ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9070 				cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
9071 				cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
9072 				cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST;
9073 				cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB;
9074 				cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff;
9075 				cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff;
9076 				cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff;
9077 				cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff;
9078 				cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff;
9079 				cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff;
9080 				cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff;
9081 				cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff;
9082 
9083 				ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9084 					   IPR_CANCEL_TIMEOUT);
9085 
9086 				rc = IPR_RC_JOB_RETURN;
9087 				ipr_cmd->job_step = ipr_reset_cancel_hcam;
9088 				break;
9089 			}
9090 		}
9091 	} else
9092 		ipr_cmd->job_step = ipr_reset_alert;
9093 
9094 	LEAVE;
9095 	return rc;
9096 }
9097 
9098 /**
9099  * ipr_reset_ucode_download_done - Microcode download completion
9100  * @ipr_cmd:	ipr command struct
9101  *
9102  * Description: This function unmaps the microcode download buffer.
9103  *
9104  * Return value:
9105  * 	IPR_RC_JOB_CONTINUE
9106  **/
9107 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
9108 {
9109 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9110 	struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9111 
9112 	dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
9113 		     sglist->num_sg, DMA_TO_DEVICE);
9114 
9115 	ipr_cmd->job_step = ipr_reset_alert;
9116 	return IPR_RC_JOB_CONTINUE;
9117 }
9118 
9119 /**
9120  * ipr_reset_ucode_download - Download microcode to the adapter
9121  * @ipr_cmd:	ipr command struct
9122  *
9123  * Description: This function checks to see if it there is microcode
9124  * to download to the adapter. If there is, a download is performed.
9125  *
9126  * Return value:
9127  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9128  **/
9129 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
9130 {
9131 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9132 	struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9133 
9134 	ENTER;
9135 	ipr_cmd->job_step = ipr_reset_alert;
9136 
9137 	if (!sglist)
9138 		return IPR_RC_JOB_CONTINUE;
9139 
9140 	ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9141 	ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
9142 	ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
9143 	ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
9144 	ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
9145 	ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
9146 	ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
9147 
9148 	if (ioa_cfg->sis64)
9149 		ipr_build_ucode_ioadl64(ipr_cmd, sglist);
9150 	else
9151 		ipr_build_ucode_ioadl(ipr_cmd, sglist);
9152 	ipr_cmd->job_step = ipr_reset_ucode_download_done;
9153 
9154 	ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9155 		   IPR_WRITE_BUFFER_TIMEOUT);
9156 
9157 	LEAVE;
9158 	return IPR_RC_JOB_RETURN;
9159 }
9160 
9161 /**
9162  * ipr_reset_shutdown_ioa - Shutdown the adapter
9163  * @ipr_cmd:	ipr command struct
9164  *
9165  * Description: This function issues an adapter shutdown of the
9166  * specified type to the specified adapter as part of the
9167  * adapter reset job.
9168  *
9169  * Return value:
9170  * 	IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9171  **/
9172 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
9173 {
9174 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9175 	enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
9176 	unsigned long timeout;
9177 	int rc = IPR_RC_JOB_CONTINUE;
9178 
9179 	ENTER;
9180 	if (shutdown_type == IPR_SHUTDOWN_QUIESCE)
9181 		ipr_cmd->job_step = ipr_reset_cancel_hcam;
9182 	else if (shutdown_type != IPR_SHUTDOWN_NONE &&
9183 			!ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
9184 		ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9185 		ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9186 		ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
9187 		ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
9188 
9189 		if (shutdown_type == IPR_SHUTDOWN_NORMAL)
9190 			timeout = IPR_SHUTDOWN_TIMEOUT;
9191 		else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
9192 			timeout = IPR_INTERNAL_TIMEOUT;
9193 		else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
9194 			timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
9195 		else
9196 			timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
9197 
9198 		ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
9199 
9200 		rc = IPR_RC_JOB_RETURN;
9201 		ipr_cmd->job_step = ipr_reset_ucode_download;
9202 	} else
9203 		ipr_cmd->job_step = ipr_reset_alert;
9204 
9205 	LEAVE;
9206 	return rc;
9207 }
9208 
9209 /**
9210  * ipr_reset_ioa_job - Adapter reset job
9211  * @ipr_cmd:	ipr command struct
9212  *
9213  * Description: This function is the job router for the adapter reset job.
9214  *
9215  * Return value:
9216  * 	none
9217  **/
9218 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
9219 {
9220 	u32 rc, ioasc;
9221 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9222 
9223 	do {
9224 		ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
9225 
9226 		if (ioa_cfg->reset_cmd != ipr_cmd) {
9227 			/*
9228 			 * We are doing nested adapter resets and this is
9229 			 * not the current reset job.
9230 			 */
9231 			list_add_tail(&ipr_cmd->queue,
9232 					&ipr_cmd->hrrq->hrrq_free_q);
9233 			return;
9234 		}
9235 
9236 		if (IPR_IOASC_SENSE_KEY(ioasc)) {
9237 			rc = ipr_cmd->job_step_failed(ipr_cmd);
9238 			if (rc == IPR_RC_JOB_RETURN)
9239 				return;
9240 		}
9241 
9242 		ipr_reinit_ipr_cmnd(ipr_cmd);
9243 		ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
9244 		rc = ipr_cmd->job_step(ipr_cmd);
9245 	} while (rc == IPR_RC_JOB_CONTINUE);
9246 }
9247 
9248 /**
9249  * _ipr_initiate_ioa_reset - Initiate an adapter reset
9250  * @ioa_cfg:		ioa config struct
9251  * @job_step:		first job step of reset job
9252  * @shutdown_type:	shutdown type
9253  *
9254  * Description: This function will initiate the reset of the given adapter
9255  * starting at the selected job step.
9256  * If the caller needs to wait on the completion of the reset,
9257  * the caller must sleep on the reset_wait_q.
9258  *
9259  * Return value:
9260  * 	none
9261  **/
9262 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9263 				    int (*job_step) (struct ipr_cmnd *),
9264 				    enum ipr_shutdown_type shutdown_type)
9265 {
9266 	struct ipr_cmnd *ipr_cmd;
9267 	int i;
9268 
9269 	ioa_cfg->in_reset_reload = 1;
9270 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9271 		spin_lock(&ioa_cfg->hrrq[i]._lock);
9272 		ioa_cfg->hrrq[i].allow_cmds = 0;
9273 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
9274 	}
9275 	wmb();
9276 	if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9277 		ioa_cfg->scsi_unblock = 0;
9278 		ioa_cfg->scsi_blocked = 1;
9279 		scsi_block_requests(ioa_cfg->host);
9280 	}
9281 
9282 	ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
9283 	ioa_cfg->reset_cmd = ipr_cmd;
9284 	ipr_cmd->job_step = job_step;
9285 	ipr_cmd->u.shutdown_type = shutdown_type;
9286 
9287 	ipr_reset_ioa_job(ipr_cmd);
9288 }
9289 
9290 /**
9291  * ipr_initiate_ioa_reset - Initiate an adapter reset
9292  * @ioa_cfg:		ioa config struct
9293  * @shutdown_type:	shutdown type
9294  *
9295  * Description: This function will initiate the reset of the given adapter.
9296  * If the caller needs to wait on the completion of the reset,
9297  * the caller must sleep on the reset_wait_q.
9298  *
9299  * Return value:
9300  * 	none
9301  **/
9302 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9303 				   enum ipr_shutdown_type shutdown_type)
9304 {
9305 	int i;
9306 
9307 	if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
9308 		return;
9309 
9310 	if (ioa_cfg->in_reset_reload) {
9311 		if (ioa_cfg->sdt_state == GET_DUMP)
9312 			ioa_cfg->sdt_state = WAIT_FOR_DUMP;
9313 		else if (ioa_cfg->sdt_state == READ_DUMP)
9314 			ioa_cfg->sdt_state = ABORT_DUMP;
9315 	}
9316 
9317 	if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
9318 		dev_err(&ioa_cfg->pdev->dev,
9319 			"IOA taken offline - error recovery failed\n");
9320 
9321 		ioa_cfg->reset_retries = 0;
9322 		for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9323 			spin_lock(&ioa_cfg->hrrq[i]._lock);
9324 			ioa_cfg->hrrq[i].ioa_is_dead = 1;
9325 			spin_unlock(&ioa_cfg->hrrq[i]._lock);
9326 		}
9327 		wmb();
9328 
9329 		if (ioa_cfg->in_ioa_bringdown) {
9330 			ioa_cfg->reset_cmd = NULL;
9331 			ioa_cfg->in_reset_reload = 0;
9332 			ipr_fail_all_ops(ioa_cfg);
9333 			wake_up_all(&ioa_cfg->reset_wait_q);
9334 
9335 			if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9336 				ioa_cfg->scsi_unblock = 1;
9337 				schedule_work(&ioa_cfg->work_q);
9338 			}
9339 			return;
9340 		} else {
9341 			ioa_cfg->in_ioa_bringdown = 1;
9342 			shutdown_type = IPR_SHUTDOWN_NONE;
9343 		}
9344 	}
9345 
9346 	_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
9347 				shutdown_type);
9348 }
9349 
9350 /**
9351  * ipr_reset_freeze - Hold off all I/O activity
9352  * @ipr_cmd:	ipr command struct
9353  *
9354  * Description: If the PCI slot is frozen, hold off all I/O
9355  * activity; then, as soon as the slot is available again,
9356  * initiate an adapter reset.
9357  */
9358 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
9359 {
9360 	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9361 	int i;
9362 
9363 	/* Disallow new interrupts, avoid loop */
9364 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9365 		spin_lock(&ioa_cfg->hrrq[i]._lock);
9366 		ioa_cfg->hrrq[i].allow_interrupts = 0;
9367 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
9368 	}
9369 	wmb();
9370 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
9371 	ipr_cmd->done = ipr_reset_ioa_job;
9372 	return IPR_RC_JOB_RETURN;
9373 }
9374 
9375 /**
9376  * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9377  * @pdev:	PCI device struct
9378  *
9379  * Description: This routine is called to tell us that the MMIO
9380  * access to the IOA has been restored
9381  */
9382 static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev)
9383 {
9384 	unsigned long flags = 0;
9385 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9386 
9387 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9388 	if (!ioa_cfg->probe_done)
9389 		pci_save_state(pdev);
9390 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9391 	return PCI_ERS_RESULT_NEED_RESET;
9392 }
9393 
9394 /**
9395  * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9396  * @pdev:	PCI device struct
9397  *
9398  * Description: This routine is called to tell us that the PCI bus
9399  * is down. Can't do anything here, except put the device driver
9400  * into a holding pattern, waiting for the PCI bus to come back.
9401  */
9402 static void ipr_pci_frozen(struct pci_dev *pdev)
9403 {
9404 	unsigned long flags = 0;
9405 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9406 
9407 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9408 	if (ioa_cfg->probe_done)
9409 		_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
9410 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9411 }
9412 
9413 /**
9414  * ipr_pci_slot_reset - Called when PCI slot has been reset.
9415  * @pdev:	PCI device struct
9416  *
9417  * Description: This routine is called by the pci error recovery
9418  * code after the PCI slot has been reset, just before we
9419  * should resume normal operations.
9420  */
9421 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
9422 {
9423 	unsigned long flags = 0;
9424 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9425 
9426 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9427 	if (ioa_cfg->probe_done) {
9428 		if (ioa_cfg->needs_warm_reset)
9429 			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9430 		else
9431 			_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
9432 						IPR_SHUTDOWN_NONE);
9433 	} else
9434 		wake_up_all(&ioa_cfg->eeh_wait_q);
9435 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9436 	return PCI_ERS_RESULT_RECOVERED;
9437 }
9438 
9439 /**
9440  * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9441  * @pdev:	PCI device struct
9442  *
9443  * Description: This routine is called when the PCI bus has
9444  * permanently failed.
9445  */
9446 static void ipr_pci_perm_failure(struct pci_dev *pdev)
9447 {
9448 	unsigned long flags = 0;
9449 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9450 	int i;
9451 
9452 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9453 	if (ioa_cfg->probe_done) {
9454 		if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
9455 			ioa_cfg->sdt_state = ABORT_DUMP;
9456 		ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
9457 		ioa_cfg->in_ioa_bringdown = 1;
9458 		for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9459 			spin_lock(&ioa_cfg->hrrq[i]._lock);
9460 			ioa_cfg->hrrq[i].allow_cmds = 0;
9461 			spin_unlock(&ioa_cfg->hrrq[i]._lock);
9462 		}
9463 		wmb();
9464 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9465 	} else
9466 		wake_up_all(&ioa_cfg->eeh_wait_q);
9467 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9468 }
9469 
9470 /**
9471  * ipr_pci_error_detected - Called when a PCI error is detected.
9472  * @pdev:	PCI device struct
9473  * @state:	PCI channel state
9474  *
9475  * Description: Called when a PCI error is detected.
9476  *
9477  * Return value:
9478  * 	PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9479  */
9480 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
9481 					       pci_channel_state_t state)
9482 {
9483 	switch (state) {
9484 	case pci_channel_io_frozen:
9485 		ipr_pci_frozen(pdev);
9486 		return PCI_ERS_RESULT_CAN_RECOVER;
9487 	case pci_channel_io_perm_failure:
9488 		ipr_pci_perm_failure(pdev);
9489 		return PCI_ERS_RESULT_DISCONNECT;
9490 	default:
9491 		break;
9492 	}
9493 	return PCI_ERS_RESULT_NEED_RESET;
9494 }
9495 
9496 /**
9497  * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9498  * @ioa_cfg:	ioa cfg struct
9499  *
9500  * Description: This is the second phase of adapter initialization
9501  * This function takes care of initilizing the adapter to the point
9502  * where it can accept new commands.
9503  * Return value:
9504  * 	0 on success / -EIO on failure
9505  **/
9506 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
9507 {
9508 	int rc = 0;
9509 	unsigned long host_lock_flags = 0;
9510 
9511 	ENTER;
9512 	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
9513 	dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
9514 	ioa_cfg->probe_done = 1;
9515 	if (ioa_cfg->needs_hard_reset) {
9516 		ioa_cfg->needs_hard_reset = 0;
9517 		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9518 	} else
9519 		_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
9520 					IPR_SHUTDOWN_NONE);
9521 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
9522 
9523 	LEAVE;
9524 	return rc;
9525 }
9526 
9527 /**
9528  * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9529  * @ioa_cfg:	ioa config struct
9530  *
9531  * Return value:
9532  * 	none
9533  **/
9534 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9535 {
9536 	int i;
9537 
9538 	if (ioa_cfg->ipr_cmnd_list) {
9539 		for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9540 			if (ioa_cfg->ipr_cmnd_list[i])
9541 				dma_pool_free(ioa_cfg->ipr_cmd_pool,
9542 					      ioa_cfg->ipr_cmnd_list[i],
9543 					      ioa_cfg->ipr_cmnd_list_dma[i]);
9544 
9545 			ioa_cfg->ipr_cmnd_list[i] = NULL;
9546 		}
9547 	}
9548 
9549 	dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
9550 
9551 	kfree(ioa_cfg->ipr_cmnd_list);
9552 	kfree(ioa_cfg->ipr_cmnd_list_dma);
9553 	ioa_cfg->ipr_cmnd_list = NULL;
9554 	ioa_cfg->ipr_cmnd_list_dma = NULL;
9555 	ioa_cfg->ipr_cmd_pool = NULL;
9556 }
9557 
9558 /**
9559  * ipr_free_mem - Frees memory allocated for an adapter
9560  * @ioa_cfg:	ioa cfg struct
9561  *
9562  * Return value:
9563  * 	nothing
9564  **/
9565 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
9566 {
9567 	int i;
9568 
9569 	kfree(ioa_cfg->res_entries);
9570 	dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
9571 			  ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9572 	ipr_free_cmd_blks(ioa_cfg);
9573 
9574 	for (i = 0; i < ioa_cfg->hrrq_num; i++)
9575 		dma_free_coherent(&ioa_cfg->pdev->dev,
9576 				  sizeof(u32) * ioa_cfg->hrrq[i].size,
9577 				  ioa_cfg->hrrq[i].host_rrq,
9578 				  ioa_cfg->hrrq[i].host_rrq_dma);
9579 
9580 	dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
9581 			  ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9582 
9583 	for (i = 0; i < IPR_MAX_HCAMS; i++) {
9584 		dma_free_coherent(&ioa_cfg->pdev->dev,
9585 				  sizeof(struct ipr_hostrcb),
9586 				  ioa_cfg->hostrcb[i],
9587 				  ioa_cfg->hostrcb_dma[i]);
9588 	}
9589 
9590 	ipr_free_dump(ioa_cfg);
9591 	kfree(ioa_cfg->trace);
9592 }
9593 
9594 /**
9595  * ipr_free_irqs - Free all allocated IRQs for the adapter.
9596  * @ioa_cfg:	ipr cfg struct
9597  *
9598  * This function frees all allocated IRQs for the
9599  * specified adapter.
9600  *
9601  * Return value:
9602  * 	none
9603  **/
9604 static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg)
9605 {
9606 	struct pci_dev *pdev = ioa_cfg->pdev;
9607 	int i;
9608 
9609 	for (i = 0; i < ioa_cfg->nvectors; i++)
9610 		free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]);
9611 	pci_free_irq_vectors(pdev);
9612 }
9613 
9614 /**
9615  * ipr_free_all_resources - Free all allocated resources for an adapter.
9616  * @ioa_cfg:	ioa config struct
9617  *
9618  * This function frees all allocated resources for the
9619  * specified adapter.
9620  *
9621  * Return value:
9622  * 	none
9623  **/
9624 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
9625 {
9626 	struct pci_dev *pdev = ioa_cfg->pdev;
9627 
9628 	ENTER;
9629 	ipr_free_irqs(ioa_cfg);
9630 	if (ioa_cfg->reset_work_q)
9631 		destroy_workqueue(ioa_cfg->reset_work_q);
9632 	iounmap(ioa_cfg->hdw_dma_regs);
9633 	pci_release_regions(pdev);
9634 	ipr_free_mem(ioa_cfg);
9635 	scsi_host_put(ioa_cfg->host);
9636 	pci_disable_device(pdev);
9637 	LEAVE;
9638 }
9639 
9640 /**
9641  * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9642  * @ioa_cfg:	ioa config struct
9643  *
9644  * Return value:
9645  * 	0 on success / -ENOMEM on allocation failure
9646  **/
9647 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9648 {
9649 	struct ipr_cmnd *ipr_cmd;
9650 	struct ipr_ioarcb *ioarcb;
9651 	dma_addr_t dma_addr;
9652 	int i, entries_each_hrrq, hrrq_id = 0;
9653 
9654 	ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
9655 						sizeof(struct ipr_cmnd), 512, 0);
9656 
9657 	if (!ioa_cfg->ipr_cmd_pool)
9658 		return -ENOMEM;
9659 
9660 	ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL);
9661 	ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL);
9662 
9663 	if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
9664 		ipr_free_cmd_blks(ioa_cfg);
9665 		return -ENOMEM;
9666 	}
9667 
9668 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9669 		if (ioa_cfg->hrrq_num > 1) {
9670 			if (i == 0) {
9671 				entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS;
9672 				ioa_cfg->hrrq[i].min_cmd_id = 0;
9673 				ioa_cfg->hrrq[i].max_cmd_id =
9674 					(entries_each_hrrq - 1);
9675 			} else {
9676 				entries_each_hrrq =
9677 					IPR_NUM_BASE_CMD_BLKS/
9678 					(ioa_cfg->hrrq_num - 1);
9679 				ioa_cfg->hrrq[i].min_cmd_id =
9680 					IPR_NUM_INTERNAL_CMD_BLKS +
9681 					(i - 1) * entries_each_hrrq;
9682 				ioa_cfg->hrrq[i].max_cmd_id =
9683 					(IPR_NUM_INTERNAL_CMD_BLKS +
9684 					i * entries_each_hrrq - 1);
9685 			}
9686 		} else {
9687 			entries_each_hrrq = IPR_NUM_CMD_BLKS;
9688 			ioa_cfg->hrrq[i].min_cmd_id = 0;
9689 			ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1);
9690 		}
9691 		ioa_cfg->hrrq[i].size = entries_each_hrrq;
9692 	}
9693 
9694 	BUG_ON(ioa_cfg->hrrq_num == 0);
9695 
9696 	i = IPR_NUM_CMD_BLKS -
9697 		ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1;
9698 	if (i > 0) {
9699 		ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i;
9700 		ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i;
9701 	}
9702 
9703 	for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9704 		ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool,
9705 				GFP_KERNEL, &dma_addr);
9706 
9707 		if (!ipr_cmd) {
9708 			ipr_free_cmd_blks(ioa_cfg);
9709 			return -ENOMEM;
9710 		}
9711 
9712 		ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
9713 		ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
9714 
9715 		ioarcb = &ipr_cmd->ioarcb;
9716 		ipr_cmd->dma_addr = dma_addr;
9717 		if (ioa_cfg->sis64)
9718 			ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
9719 		else
9720 			ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
9721 
9722 		ioarcb->host_response_handle = cpu_to_be32(i << 2);
9723 		if (ioa_cfg->sis64) {
9724 			ioarcb->u.sis64_addr_data.data_ioadl_addr =
9725 				cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
9726 			ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
9727 				cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
9728 		} else {
9729 			ioarcb->write_ioadl_addr =
9730 				cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
9731 			ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
9732 			ioarcb->ioasa_host_pci_addr =
9733 				cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
9734 		}
9735 		ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
9736 		ipr_cmd->cmd_index = i;
9737 		ipr_cmd->ioa_cfg = ioa_cfg;
9738 		ipr_cmd->sense_buffer_dma = dma_addr +
9739 			offsetof(struct ipr_cmnd, sense_buffer);
9740 
9741 		ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id;
9742 		ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id];
9743 		list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9744 		if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id)
9745 			hrrq_id++;
9746 	}
9747 
9748 	return 0;
9749 }
9750 
9751 /**
9752  * ipr_alloc_mem - Allocate memory for an adapter
9753  * @ioa_cfg:	ioa config struct
9754  *
9755  * Return value:
9756  * 	0 on success / non-zero for error
9757  **/
9758 static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
9759 {
9760 	struct pci_dev *pdev = ioa_cfg->pdev;
9761 	int i, rc = -ENOMEM;
9762 
9763 	ENTER;
9764 	ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported,
9765 				       sizeof(struct ipr_resource_entry),
9766 				       GFP_KERNEL);
9767 
9768 	if (!ioa_cfg->res_entries)
9769 		goto out;
9770 
9771 	for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
9772 		list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
9773 		ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
9774 	}
9775 
9776 	ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
9777 					      sizeof(struct ipr_misc_cbs),
9778 					      &ioa_cfg->vpd_cbs_dma,
9779 					      GFP_KERNEL);
9780 
9781 	if (!ioa_cfg->vpd_cbs)
9782 		goto out_free_res_entries;
9783 
9784 	if (ipr_alloc_cmd_blks(ioa_cfg))
9785 		goto out_free_vpd_cbs;
9786 
9787 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9788 		ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
9789 					sizeof(u32) * ioa_cfg->hrrq[i].size,
9790 					&ioa_cfg->hrrq[i].host_rrq_dma,
9791 					GFP_KERNEL);
9792 
9793 		if (!ioa_cfg->hrrq[i].host_rrq)  {
9794 			while (--i > 0)
9795 				dma_free_coherent(&pdev->dev,
9796 					sizeof(u32) * ioa_cfg->hrrq[i].size,
9797 					ioa_cfg->hrrq[i].host_rrq,
9798 					ioa_cfg->hrrq[i].host_rrq_dma);
9799 			goto out_ipr_free_cmd_blocks;
9800 		}
9801 		ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
9802 	}
9803 
9804 	ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
9805 						  ioa_cfg->cfg_table_size,
9806 						  &ioa_cfg->cfg_table_dma,
9807 						  GFP_KERNEL);
9808 
9809 	if (!ioa_cfg->u.cfg_table)
9810 		goto out_free_host_rrq;
9811 
9812 	for (i = 0; i < IPR_MAX_HCAMS; i++) {
9813 		ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
9814 							 sizeof(struct ipr_hostrcb),
9815 							 &ioa_cfg->hostrcb_dma[i],
9816 							 GFP_KERNEL);
9817 
9818 		if (!ioa_cfg->hostrcb[i])
9819 			goto out_free_hostrcb_dma;
9820 
9821 		ioa_cfg->hostrcb[i]->hostrcb_dma =
9822 			ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
9823 		ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
9824 		list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
9825 	}
9826 
9827 	ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES,
9828 				 sizeof(struct ipr_trace_entry),
9829 				 GFP_KERNEL);
9830 
9831 	if (!ioa_cfg->trace)
9832 		goto out_free_hostrcb_dma;
9833 
9834 	rc = 0;
9835 out:
9836 	LEAVE;
9837 	return rc;
9838 
9839 out_free_hostrcb_dma:
9840 	while (i-- > 0) {
9841 		dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
9842 				  ioa_cfg->hostrcb[i],
9843 				  ioa_cfg->hostrcb_dma[i]);
9844 	}
9845 	dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
9846 			  ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9847 out_free_host_rrq:
9848 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9849 		dma_free_coherent(&pdev->dev,
9850 				  sizeof(u32) * ioa_cfg->hrrq[i].size,
9851 				  ioa_cfg->hrrq[i].host_rrq,
9852 				  ioa_cfg->hrrq[i].host_rrq_dma);
9853 	}
9854 out_ipr_free_cmd_blocks:
9855 	ipr_free_cmd_blks(ioa_cfg);
9856 out_free_vpd_cbs:
9857 	dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
9858 			  ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9859 out_free_res_entries:
9860 	kfree(ioa_cfg->res_entries);
9861 	goto out;
9862 }
9863 
9864 /**
9865  * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9866  * @ioa_cfg:	ioa config struct
9867  *
9868  * Return value:
9869  * 	none
9870  **/
9871 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
9872 {
9873 	int i;
9874 
9875 	for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
9876 		ioa_cfg->bus_attr[i].bus = i;
9877 		ioa_cfg->bus_attr[i].qas_enabled = 0;
9878 		ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
9879 		if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
9880 			ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
9881 		else
9882 			ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
9883 	}
9884 }
9885 
9886 /**
9887  * ipr_init_regs - Initialize IOA registers
9888  * @ioa_cfg:	ioa config struct
9889  *
9890  * Return value:
9891  *	none
9892  **/
9893 static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg)
9894 {
9895 	const struct ipr_interrupt_offsets *p;
9896 	struct ipr_interrupts *t;
9897 	void __iomem *base;
9898 
9899 	p = &ioa_cfg->chip_cfg->regs;
9900 	t = &ioa_cfg->regs;
9901 	base = ioa_cfg->hdw_dma_regs;
9902 
9903 	t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
9904 	t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
9905 	t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
9906 	t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
9907 	t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
9908 	t->clr_interrupt_reg = base + p->clr_interrupt_reg;
9909 	t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
9910 	t->sense_interrupt_reg = base + p->sense_interrupt_reg;
9911 	t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
9912 	t->ioarrin_reg = base + p->ioarrin_reg;
9913 	t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
9914 	t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
9915 	t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
9916 	t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
9917 	t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
9918 	t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
9919 
9920 	if (ioa_cfg->sis64) {
9921 		t->init_feedback_reg = base + p->init_feedback_reg;
9922 		t->dump_addr_reg = base + p->dump_addr_reg;
9923 		t->dump_data_reg = base + p->dump_data_reg;
9924 		t->endian_swap_reg = base + p->endian_swap_reg;
9925 	}
9926 }
9927 
9928 /**
9929  * ipr_init_ioa_cfg - Initialize IOA config struct
9930  * @ioa_cfg:	ioa config struct
9931  * @host:		scsi host struct
9932  * @pdev:		PCI dev struct
9933  *
9934  * Return value:
9935  * 	none
9936  **/
9937 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
9938 			     struct Scsi_Host *host, struct pci_dev *pdev)
9939 {
9940 	int i;
9941 
9942 	ioa_cfg->host = host;
9943 	ioa_cfg->pdev = pdev;
9944 	ioa_cfg->log_level = ipr_log_level;
9945 	ioa_cfg->doorbell = IPR_DOORBELL;
9946 	sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
9947 	sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
9948 	sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
9949 	sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
9950 	sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
9951 	sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
9952 
9953 	INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
9954 	INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
9955 	INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q);
9956 	INIT_LIST_HEAD(&ioa_cfg->free_res_q);
9957 	INIT_LIST_HEAD(&ioa_cfg->used_res_q);
9958 	INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
9959 	INIT_WORK(&ioa_cfg->scsi_add_work_q, ipr_add_remove_thread);
9960 	init_waitqueue_head(&ioa_cfg->reset_wait_q);
9961 	init_waitqueue_head(&ioa_cfg->msi_wait_q);
9962 	init_waitqueue_head(&ioa_cfg->eeh_wait_q);
9963 	ioa_cfg->sdt_state = INACTIVE;
9964 
9965 	ipr_initialize_bus_attr(ioa_cfg);
9966 	ioa_cfg->max_devs_supported = ipr_max_devs;
9967 
9968 	if (ioa_cfg->sis64) {
9969 		host->max_channel = IPR_MAX_SIS64_BUSES;
9970 		host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
9971 		host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
9972 		if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
9973 			ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
9974 		ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
9975 					   + ((sizeof(struct ipr_config_table_entry64)
9976 					       * ioa_cfg->max_devs_supported)));
9977 	} else {
9978 		host->max_channel = IPR_VSET_BUS;
9979 		host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
9980 		host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
9981 		if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
9982 			ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
9983 		ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
9984 					   + ((sizeof(struct ipr_config_table_entry)
9985 					       * ioa_cfg->max_devs_supported)));
9986 	}
9987 
9988 	host->unique_id = host->host_no;
9989 	host->max_cmd_len = IPR_MAX_CDB_LEN;
9990 	host->can_queue = ioa_cfg->max_cmds;
9991 	pci_set_drvdata(pdev, ioa_cfg);
9992 
9993 	for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) {
9994 		INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q);
9995 		INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q);
9996 		spin_lock_init(&ioa_cfg->hrrq[i]._lock);
9997 		if (i == 0)
9998 			ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock;
9999 		else
10000 			ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock;
10001 	}
10002 }
10003 
10004 /**
10005  * ipr_get_chip_info - Find adapter chip information
10006  * @dev_id:		PCI device id struct
10007  *
10008  * Return value:
10009  * 	ptr to chip information on success / NULL on failure
10010  **/
10011 static const struct ipr_chip_t *
10012 ipr_get_chip_info(const struct pci_device_id *dev_id)
10013 {
10014 	int i;
10015 
10016 	for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
10017 		if (ipr_chip[i].vendor == dev_id->vendor &&
10018 		    ipr_chip[i].device == dev_id->device)
10019 			return &ipr_chip[i];
10020 	return NULL;
10021 }
10022 
10023 /**
10024  * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
10025  *						during probe time
10026  * @ioa_cfg:	ioa config struct
10027  *
10028  * Return value:
10029  * 	None
10030  **/
10031 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg)
10032 {
10033 	struct pci_dev *pdev = ioa_cfg->pdev;
10034 
10035 	if (pci_channel_offline(pdev)) {
10036 		wait_event_timeout(ioa_cfg->eeh_wait_q,
10037 				   !pci_channel_offline(pdev),
10038 				   IPR_PCI_ERROR_RECOVERY_TIMEOUT);
10039 		pci_restore_state(pdev);
10040 	}
10041 }
10042 
10043 static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg)
10044 {
10045 	int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1;
10046 
10047 	for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) {
10048 		snprintf(ioa_cfg->vectors_info[vec_idx].desc, n,
10049 			 "host%d-%d", ioa_cfg->host->host_no, vec_idx);
10050 		ioa_cfg->vectors_info[vec_idx].
10051 			desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0;
10052 	}
10053 }
10054 
10055 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg,
10056 		struct pci_dev *pdev)
10057 {
10058 	int i, rc;
10059 
10060 	for (i = 1; i < ioa_cfg->nvectors; i++) {
10061 		rc = request_irq(pci_irq_vector(pdev, i),
10062 			ipr_isr_mhrrq,
10063 			0,
10064 			ioa_cfg->vectors_info[i].desc,
10065 			&ioa_cfg->hrrq[i]);
10066 		if (rc) {
10067 			while (--i >= 0)
10068 				free_irq(pci_irq_vector(pdev, i),
10069 					&ioa_cfg->hrrq[i]);
10070 			return rc;
10071 		}
10072 	}
10073 	return 0;
10074 }
10075 
10076 /**
10077  * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
10078  * @devp:		PCI device struct
10079  * @irq:		IRQ number
10080  *
10081  * Description: Simply set the msi_received flag to 1 indicating that
10082  * Message Signaled Interrupts are supported.
10083  *
10084  * Return value:
10085  * 	0 on success / non-zero on failure
10086  **/
10087 static irqreturn_t ipr_test_intr(int irq, void *devp)
10088 {
10089 	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
10090 	unsigned long lock_flags = 0;
10091 	irqreturn_t rc = IRQ_HANDLED;
10092 
10093 	dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq);
10094 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10095 
10096 	ioa_cfg->msi_received = 1;
10097 	wake_up(&ioa_cfg->msi_wait_q);
10098 
10099 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10100 	return rc;
10101 }
10102 
10103 /**
10104  * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
10105  * @ioa_cfg:		ioa config struct
10106  * @pdev:		PCI device struct
10107  *
10108  * Description: This routine sets up and initiates a test interrupt to determine
10109  * if the interrupt is received via the ipr_test_intr() service routine.
10110  * If the tests fails, the driver will fall back to LSI.
10111  *
10112  * Return value:
10113  * 	0 on success / non-zero on failure
10114  **/
10115 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
10116 {
10117 	int rc;
10118 	unsigned long lock_flags = 0;
10119 	int irq = pci_irq_vector(pdev, 0);
10120 
10121 	ENTER;
10122 
10123 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10124 	init_waitqueue_head(&ioa_cfg->msi_wait_q);
10125 	ioa_cfg->msi_received = 0;
10126 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10127 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
10128 	readl(ioa_cfg->regs.sense_interrupt_mask_reg);
10129 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10130 
10131 	rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
10132 	if (rc) {
10133 		dev_err(&pdev->dev, "Can not assign irq %d\n", irq);
10134 		return rc;
10135 	} else if (ipr_debug)
10136 		dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
10137 
10138 	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
10139 	readl(ioa_cfg->regs.sense_interrupt_reg);
10140 	wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
10141 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10142 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10143 
10144 	if (!ioa_cfg->msi_received) {
10145 		/* MSI test failed */
10146 		dev_info(&pdev->dev, "MSI test failed.  Falling back to LSI.\n");
10147 		rc = -EOPNOTSUPP;
10148 	} else if (ipr_debug)
10149 		dev_info(&pdev->dev, "MSI test succeeded.\n");
10150 
10151 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10152 
10153 	free_irq(irq, ioa_cfg);
10154 
10155 	LEAVE;
10156 
10157 	return rc;
10158 }
10159 
10160  /* ipr_probe_ioa - Allocates memory and does first stage of initialization
10161  * @pdev:		PCI device struct
10162  * @dev_id:		PCI device id struct
10163  *
10164  * Return value:
10165  * 	0 on success / non-zero on failure
10166  **/
10167 static int ipr_probe_ioa(struct pci_dev *pdev,
10168 			 const struct pci_device_id *dev_id)
10169 {
10170 	struct ipr_ioa_cfg *ioa_cfg;
10171 	struct Scsi_Host *host;
10172 	unsigned long ipr_regs_pci;
10173 	void __iomem *ipr_regs;
10174 	int rc = PCIBIOS_SUCCESSFUL;
10175 	volatile u32 mask, uproc, interrupts;
10176 	unsigned long lock_flags, driver_lock_flags;
10177 	unsigned int irq_flag;
10178 
10179 	ENTER;
10180 
10181 	dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
10182 	host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
10183 
10184 	if (!host) {
10185 		dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
10186 		rc = -ENOMEM;
10187 		goto out;
10188 	}
10189 
10190 	ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
10191 	memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
10192 	ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops);
10193 
10194 	ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
10195 
10196 	if (!ioa_cfg->ipr_chip) {
10197 		dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
10198 			dev_id->vendor, dev_id->device);
10199 		goto out_scsi_host_put;
10200 	}
10201 
10202 	/* set SIS 32 or SIS 64 */
10203 	ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
10204 	ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
10205 	ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr;
10206 	ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds;
10207 
10208 	if (ipr_transop_timeout)
10209 		ioa_cfg->transop_timeout = ipr_transop_timeout;
10210 	else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
10211 		ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
10212 	else
10213 		ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
10214 
10215 	ioa_cfg->revid = pdev->revision;
10216 
10217 	ipr_init_ioa_cfg(ioa_cfg, host, pdev);
10218 
10219 	ipr_regs_pci = pci_resource_start(pdev, 0);
10220 
10221 	rc = pci_request_regions(pdev, IPR_NAME);
10222 	if (rc < 0) {
10223 		dev_err(&pdev->dev,
10224 			"Couldn't register memory range of registers\n");
10225 		goto out_scsi_host_put;
10226 	}
10227 
10228 	rc = pci_enable_device(pdev);
10229 
10230 	if (rc || pci_channel_offline(pdev)) {
10231 		if (pci_channel_offline(pdev)) {
10232 			ipr_wait_for_pci_err_recovery(ioa_cfg);
10233 			rc = pci_enable_device(pdev);
10234 		}
10235 
10236 		if (rc) {
10237 			dev_err(&pdev->dev, "Cannot enable adapter\n");
10238 			ipr_wait_for_pci_err_recovery(ioa_cfg);
10239 			goto out_release_regions;
10240 		}
10241 	}
10242 
10243 	ipr_regs = pci_ioremap_bar(pdev, 0);
10244 
10245 	if (!ipr_regs) {
10246 		dev_err(&pdev->dev,
10247 			"Couldn't map memory range of registers\n");
10248 		rc = -ENOMEM;
10249 		goto out_disable;
10250 	}
10251 
10252 	ioa_cfg->hdw_dma_regs = ipr_regs;
10253 	ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
10254 	ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
10255 
10256 	ipr_init_regs(ioa_cfg);
10257 
10258 	if (ioa_cfg->sis64) {
10259 		rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
10260 		if (rc < 0) {
10261 			dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
10262 			rc = dma_set_mask_and_coherent(&pdev->dev,
10263 						       DMA_BIT_MASK(32));
10264 		}
10265 	} else
10266 		rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
10267 
10268 	if (rc < 0) {
10269 		dev_err(&pdev->dev, "Failed to set DMA mask\n");
10270 		goto cleanup_nomem;
10271 	}
10272 
10273 	rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
10274 				   ioa_cfg->chip_cfg->cache_line_size);
10275 
10276 	if (rc != PCIBIOS_SUCCESSFUL) {
10277 		dev_err(&pdev->dev, "Write of cache line size failed\n");
10278 		ipr_wait_for_pci_err_recovery(ioa_cfg);
10279 		rc = -EIO;
10280 		goto cleanup_nomem;
10281 	}
10282 
10283 	/* Issue MMIO read to ensure card is not in EEH */
10284 	interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
10285 	ipr_wait_for_pci_err_recovery(ioa_cfg);
10286 
10287 	if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) {
10288 		dev_err(&pdev->dev, "The max number of MSIX is %d\n",
10289 			IPR_MAX_MSIX_VECTORS);
10290 		ipr_number_of_msix = IPR_MAX_MSIX_VECTORS;
10291 	}
10292 
10293 	irq_flag = PCI_IRQ_LEGACY;
10294 	if (ioa_cfg->ipr_chip->has_msi)
10295 		irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX;
10296 	rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag);
10297 	if (rc < 0) {
10298 		ipr_wait_for_pci_err_recovery(ioa_cfg);
10299 		goto cleanup_nomem;
10300 	}
10301 	ioa_cfg->nvectors = rc;
10302 
10303 	if (!pdev->msi_enabled && !pdev->msix_enabled)
10304 		ioa_cfg->clear_isr = 1;
10305 
10306 	pci_set_master(pdev);
10307 
10308 	if (pci_channel_offline(pdev)) {
10309 		ipr_wait_for_pci_err_recovery(ioa_cfg);
10310 		pci_set_master(pdev);
10311 		if (pci_channel_offline(pdev)) {
10312 			rc = -EIO;
10313 			goto out_msi_disable;
10314 		}
10315 	}
10316 
10317 	if (pdev->msi_enabled || pdev->msix_enabled) {
10318 		rc = ipr_test_msi(ioa_cfg, pdev);
10319 		switch (rc) {
10320 		case 0:
10321 			dev_info(&pdev->dev,
10322 				"Request for %d MSI%ss succeeded.", ioa_cfg->nvectors,
10323 				pdev->msix_enabled ? "-X" : "");
10324 			break;
10325 		case -EOPNOTSUPP:
10326 			ipr_wait_for_pci_err_recovery(ioa_cfg);
10327 			pci_free_irq_vectors(pdev);
10328 
10329 			ioa_cfg->nvectors = 1;
10330 			ioa_cfg->clear_isr = 1;
10331 			break;
10332 		default:
10333 			goto out_msi_disable;
10334 		}
10335 	}
10336 
10337 	ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors,
10338 				(unsigned int)num_online_cpus(),
10339 				(unsigned int)IPR_MAX_HRRQ_NUM);
10340 
10341 	if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
10342 		goto out_msi_disable;
10343 
10344 	if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
10345 		goto out_msi_disable;
10346 
10347 	rc = ipr_alloc_mem(ioa_cfg);
10348 	if (rc < 0) {
10349 		dev_err(&pdev->dev,
10350 			"Couldn't allocate enough memory for device driver!\n");
10351 		goto out_msi_disable;
10352 	}
10353 
10354 	/* Save away PCI config space for use following IOA reset */
10355 	rc = pci_save_state(pdev);
10356 
10357 	if (rc != PCIBIOS_SUCCESSFUL) {
10358 		dev_err(&pdev->dev, "Failed to save PCI config space\n");
10359 		rc = -EIO;
10360 		goto cleanup_nolog;
10361 	}
10362 
10363 	/*
10364 	 * If HRRQ updated interrupt is not masked, or reset alert is set,
10365 	 * the card is in an unknown state and needs a hard reset
10366 	 */
10367 	mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
10368 	interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
10369 	uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
10370 	if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
10371 		ioa_cfg->needs_hard_reset = 1;
10372 	if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices)
10373 		ioa_cfg->needs_hard_reset = 1;
10374 	if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
10375 		ioa_cfg->ioa_unit_checked = 1;
10376 
10377 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10378 	ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10379 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10380 
10381 	if (pdev->msi_enabled || pdev->msix_enabled) {
10382 		name_msi_vectors(ioa_cfg);
10383 		rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0,
10384 			ioa_cfg->vectors_info[0].desc,
10385 			&ioa_cfg->hrrq[0]);
10386 		if (!rc)
10387 			rc = ipr_request_other_msi_irqs(ioa_cfg, pdev);
10388 	} else {
10389 		rc = request_irq(pdev->irq, ipr_isr,
10390 			 IRQF_SHARED,
10391 			 IPR_NAME, &ioa_cfg->hrrq[0]);
10392 	}
10393 	if (rc) {
10394 		dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
10395 			pdev->irq, rc);
10396 		goto cleanup_nolog;
10397 	}
10398 
10399 	if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
10400 	    (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
10401 		ioa_cfg->needs_warm_reset = 1;
10402 		ioa_cfg->reset = ipr_reset_slot_reset;
10403 
10404 		ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d",
10405 								WQ_MEM_RECLAIM, host->host_no);
10406 
10407 		if (!ioa_cfg->reset_work_q) {
10408 			dev_err(&pdev->dev, "Couldn't register reset workqueue\n");
10409 			rc = -ENOMEM;
10410 			goto out_free_irq;
10411 		}
10412 	} else
10413 		ioa_cfg->reset = ipr_reset_start_bist;
10414 
10415 	spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10416 	list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
10417 	spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10418 
10419 	LEAVE;
10420 out:
10421 	return rc;
10422 
10423 out_free_irq:
10424 	ipr_free_irqs(ioa_cfg);
10425 cleanup_nolog:
10426 	ipr_free_mem(ioa_cfg);
10427 out_msi_disable:
10428 	ipr_wait_for_pci_err_recovery(ioa_cfg);
10429 	pci_free_irq_vectors(pdev);
10430 cleanup_nomem:
10431 	iounmap(ipr_regs);
10432 out_disable:
10433 	pci_disable_device(pdev);
10434 out_release_regions:
10435 	pci_release_regions(pdev);
10436 out_scsi_host_put:
10437 	scsi_host_put(host);
10438 	goto out;
10439 }
10440 
10441 /**
10442  * ipr_initiate_ioa_bringdown - Bring down an adapter
10443  * @ioa_cfg:		ioa config struct
10444  * @shutdown_type:	shutdown type
10445  *
10446  * Description: This function will initiate bringing down the adapter.
10447  * This consists of issuing an IOA shutdown to the adapter
10448  * to flush the cache, and running BIST.
10449  * If the caller needs to wait on the completion of the reset,
10450  * the caller must sleep on the reset_wait_q.
10451  *
10452  * Return value:
10453  * 	none
10454  **/
10455 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
10456 				       enum ipr_shutdown_type shutdown_type)
10457 {
10458 	ENTER;
10459 	if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
10460 		ioa_cfg->sdt_state = ABORT_DUMP;
10461 	ioa_cfg->reset_retries = 0;
10462 	ioa_cfg->in_ioa_bringdown = 1;
10463 	ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
10464 	LEAVE;
10465 }
10466 
10467 /**
10468  * __ipr_remove - Remove a single adapter
10469  * @pdev:	pci device struct
10470  *
10471  * Adapter hot plug remove entry point.
10472  *
10473  * Return value:
10474  * 	none
10475  **/
10476 static void __ipr_remove(struct pci_dev *pdev)
10477 {
10478 	unsigned long host_lock_flags = 0;
10479 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10480 	int i;
10481 	unsigned long driver_lock_flags;
10482 	ENTER;
10483 
10484 	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10485 	while (ioa_cfg->in_reset_reload) {
10486 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10487 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10488 		spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10489 	}
10490 
10491 	for (i = 0; i < ioa_cfg->hrrq_num; i++) {
10492 		spin_lock(&ioa_cfg->hrrq[i]._lock);
10493 		ioa_cfg->hrrq[i].removing_ioa = 1;
10494 		spin_unlock(&ioa_cfg->hrrq[i]._lock);
10495 	}
10496 	wmb();
10497 	ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
10498 
10499 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10500 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10501 	flush_work(&ioa_cfg->work_q);
10502 	if (ioa_cfg->reset_work_q)
10503 		flush_workqueue(ioa_cfg->reset_work_q);
10504 	INIT_LIST_HEAD(&ioa_cfg->used_res_q);
10505 	spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10506 
10507 	spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10508 	list_del(&ioa_cfg->queue);
10509 	spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10510 
10511 	if (ioa_cfg->sdt_state == ABORT_DUMP)
10512 		ioa_cfg->sdt_state = WAIT_FOR_DUMP;
10513 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10514 
10515 	ipr_free_all_resources(ioa_cfg);
10516 
10517 	LEAVE;
10518 }
10519 
10520 /**
10521  * ipr_remove - IOA hot plug remove entry point
10522  * @pdev:	pci device struct
10523  *
10524  * Adapter hot plug remove entry point.
10525  *
10526  * Return value:
10527  * 	none
10528  **/
10529 static void ipr_remove(struct pci_dev *pdev)
10530 {
10531 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10532 
10533 	ENTER;
10534 
10535 	ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10536 			      &ipr_trace_attr);
10537 	ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10538 			     &ipr_dump_attr);
10539 	sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10540 			&ipr_ioa_async_err_log);
10541 	scsi_remove_host(ioa_cfg->host);
10542 
10543 	__ipr_remove(pdev);
10544 
10545 	LEAVE;
10546 }
10547 
10548 /**
10549  * ipr_probe - Adapter hot plug add entry point
10550  * @pdev:	pci device struct
10551  * @dev_id:	pci device ID
10552  *
10553  * Return value:
10554  * 	0 on success / non-zero on failure
10555  **/
10556 static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
10557 {
10558 	struct ipr_ioa_cfg *ioa_cfg;
10559 	unsigned long flags;
10560 	int rc, i;
10561 
10562 	rc = ipr_probe_ioa(pdev, dev_id);
10563 
10564 	if (rc)
10565 		return rc;
10566 
10567 	ioa_cfg = pci_get_drvdata(pdev);
10568 	rc = ipr_probe_ioa_part2(ioa_cfg);
10569 
10570 	if (rc) {
10571 		__ipr_remove(pdev);
10572 		return rc;
10573 	}
10574 
10575 	rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
10576 
10577 	if (rc) {
10578 		__ipr_remove(pdev);
10579 		return rc;
10580 	}
10581 
10582 	rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
10583 				   &ipr_trace_attr);
10584 
10585 	if (rc) {
10586 		scsi_remove_host(ioa_cfg->host);
10587 		__ipr_remove(pdev);
10588 		return rc;
10589 	}
10590 
10591 	rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj,
10592 			&ipr_ioa_async_err_log);
10593 
10594 	if (rc) {
10595 		ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10596 				&ipr_dump_attr);
10597 		ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10598 				&ipr_trace_attr);
10599 		scsi_remove_host(ioa_cfg->host);
10600 		__ipr_remove(pdev);
10601 		return rc;
10602 	}
10603 
10604 	rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
10605 				   &ipr_dump_attr);
10606 
10607 	if (rc) {
10608 		sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10609 				      &ipr_ioa_async_err_log);
10610 		ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10611 				      &ipr_trace_attr);
10612 		scsi_remove_host(ioa_cfg->host);
10613 		__ipr_remove(pdev);
10614 		return rc;
10615 	}
10616 	spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10617 	ioa_cfg->scan_enabled = 1;
10618 	schedule_work(&ioa_cfg->work_q);
10619 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10620 
10621 	ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight;
10622 
10623 	if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10624 		for (i = 1; i < ioa_cfg->hrrq_num; i++) {
10625 			irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
10626 					ioa_cfg->iopoll_weight, ipr_iopoll);
10627 		}
10628 	}
10629 
10630 	scsi_scan_host(ioa_cfg->host);
10631 
10632 	return 0;
10633 }
10634 
10635 /**
10636  * ipr_shutdown - Shutdown handler.
10637  * @pdev:	pci device struct
10638  *
10639  * This function is invoked upon system shutdown/reboot. It will issue
10640  * an adapter shutdown to the adapter to flush the write cache.
10641  *
10642  * Return value:
10643  * 	none
10644  **/
10645 static void ipr_shutdown(struct pci_dev *pdev)
10646 {
10647 	struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10648 	unsigned long lock_flags = 0;
10649 	enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL;
10650 	int i;
10651 
10652 	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10653 	if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10654 		ioa_cfg->iopoll_weight = 0;
10655 		for (i = 1; i < ioa_cfg->hrrq_num; i++)
10656 			irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
10657 	}
10658 
10659 	while (ioa_cfg->in_reset_reload) {
10660 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10661 		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10662 		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10663 	}
10664 
10665 	if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64)
10666 		shutdown_type = IPR_SHUTDOWN_QUIESCE;
10667 
10668 	ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type);
10669 	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10670 	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10671 	if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) {
10672 		ipr_free_irqs(ioa_cfg);
10673 		pci_disable_device(ioa_cfg->pdev);
10674 	}
10675 }
10676 
10677 static struct pci_device_id ipr_pci_table[] = {
10678 	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10679 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
10680 	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10681 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
10682 	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10683 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
10684 	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10685 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
10686 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10687 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
10688 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10689 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
10690 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10691 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
10692 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10693 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
10694 		IPR_USE_LONG_TRANSOP_TIMEOUT },
10695 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10696 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10697 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10698 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10699 	      IPR_USE_LONG_TRANSOP_TIMEOUT },
10700 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10701 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10702 	      IPR_USE_LONG_TRANSOP_TIMEOUT },
10703 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10704 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10705 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10706 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10707 	      IPR_USE_LONG_TRANSOP_TIMEOUT},
10708 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10709 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10710 	      IPR_USE_LONG_TRANSOP_TIMEOUT },
10711 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10712 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
10713 	      IPR_USE_LONG_TRANSOP_TIMEOUT },
10714 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10715 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
10716 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10717 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 },
10718 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10719 	      PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
10720 	      IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
10721 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
10722 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
10723 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10724 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
10725 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10726 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
10727 		IPR_USE_LONG_TRANSOP_TIMEOUT },
10728 	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10729 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
10730 		IPR_USE_LONG_TRANSOP_TIMEOUT },
10731 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10732 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
10733 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10734 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
10735 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10736 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
10737 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10738 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 },
10739 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10740 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 },
10741 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10742 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 },
10743 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10744 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
10745 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10746 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
10747 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10748 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
10749 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10750 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 },
10751 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10752 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
10753 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10754 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 },
10755 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10756 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 },
10757 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10758 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 },
10759 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10760 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 },
10761 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10762 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 },
10763 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10764 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 },
10765 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10766 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 },
10767 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10768 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 },
10769 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10770 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 },
10771 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10772 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 },
10773 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10774 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 },
10775 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10776 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 },
10777 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10778 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 },
10779 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10780 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 },
10781 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10782 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 },
10783 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10784 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 },
10785 	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10786 		PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 },
10787 	{ }
10788 };
10789 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
10790 
10791 static const struct pci_error_handlers ipr_err_handler = {
10792 	.error_detected = ipr_pci_error_detected,
10793 	.mmio_enabled = ipr_pci_mmio_enabled,
10794 	.slot_reset = ipr_pci_slot_reset,
10795 };
10796 
10797 static struct pci_driver ipr_driver = {
10798 	.name = IPR_NAME,
10799 	.id_table = ipr_pci_table,
10800 	.probe = ipr_probe,
10801 	.remove = ipr_remove,
10802 	.shutdown = ipr_shutdown,
10803 	.err_handler = &ipr_err_handler,
10804 };
10805 
10806 /**
10807  * ipr_halt_done - Shutdown prepare completion
10808  * @ipr_cmd:   ipr command struct
10809  *
10810  * Return value:
10811  * 	none
10812  **/
10813 static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
10814 {
10815 	list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
10816 }
10817 
10818 /**
10819  * ipr_halt - Issue shutdown prepare to all adapters
10820  * @nb: Notifier block
10821  * @event: Notifier event
10822  * @buf: Notifier data (unused)
10823  *
10824  * Return value:
10825  * 	NOTIFY_OK on success / NOTIFY_DONE on failure
10826  **/
10827 static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
10828 {
10829 	struct ipr_cmnd *ipr_cmd;
10830 	struct ipr_ioa_cfg *ioa_cfg;
10831 	unsigned long flags = 0, driver_lock_flags;
10832 
10833 	if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
10834 		return NOTIFY_DONE;
10835 
10836 	spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10837 
10838 	list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
10839 		spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10840 		if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
10841 		    (ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) {
10842 			spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10843 			continue;
10844 		}
10845 
10846 		ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
10847 		ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
10848 		ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
10849 		ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
10850 		ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
10851 
10852 		ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
10853 		spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10854 	}
10855 	spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10856 
10857 	return NOTIFY_OK;
10858 }
10859 
10860 static struct notifier_block ipr_notifier = {
10861 	ipr_halt, NULL, 0
10862 };
10863 
10864 /**
10865  * ipr_init - Module entry point
10866  *
10867  * Return value:
10868  * 	0 on success / negative value on failure
10869  **/
10870 static int __init ipr_init(void)
10871 {
10872 	ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10873 		 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
10874 
10875 	register_reboot_notifier(&ipr_notifier);
10876 	return pci_register_driver(&ipr_driver);
10877 }
10878 
10879 /**
10880  * ipr_exit - Module unload
10881  *
10882  * Module unload entry point.
10883  *
10884  * Return value:
10885  * 	none
10886  **/
10887 static void __exit ipr_exit(void)
10888 {
10889 	unregister_reboot_notifier(&ipr_notifier);
10890 	pci_unregister_driver(&ipr_driver);
10891 }
10892 
10893 module_init(ipr_init);
10894 module_exit(ipr_exit);
10895