1 // SPDX-License-Identifier: GPL-2.0-or-later
3 * ipr.c -- driver for IBM Power Linux RAID adapters
5 * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
7 * Copyright (C) 2003, 2004 IBM Corporation
13 * This driver is used to control the following SCSI adapters:
15 * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
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
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
30 * - Background Parity Checking
31 * - Background Data Scrubbing
32 * - Ability to increase the capacity of an existing RAID 5 disk array
36 * - Tagged command queuing
37 * - Adapter microcode download
39 * - SCSI device hot plug
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>
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>
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);
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 */
96 .cache_line_size = 0x20,
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
118 { /* Snipe and Scamp */
121 .cache_line_size = 0x20,
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
146 .cache_line_size = 0x20,
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
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] }
187 static int ipr_max_bus_speeds[] = {
188 IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
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);
217 /* A constant array of IOASCs/URCs/Error Messages */
219 struct ipr_error_table_t ipr_error_table[] = {
220 {0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
221 "8155: An unknown error was received"},
223 "Soft underlength error"},
225 "Command to be cancelled not found"},
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"},
275 "Logical Unit in process of becoming ready"},
277 "Initializing command required"},
279 "34FF: Disk device format in progress"},
281 "Logical unit not accessible, target port in unavailable state"},
282 {0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
283 "9070: IOA requested reset"},
285 "Synchronization required"},
287 "IOA microcode download required"},
289 "Device bus connection is prohibited by host"},
291 "No ready, IOA shutdown"},
293 "Not ready, IOA has been shutdown"},
294 {0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
295 "3020: Storage subsystem configuration error"},
297 "FFF5: Medium error, data unreadable, recommend reassign"},
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"},
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"},
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"},
357 "Device bus status error"},
358 {0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
359 "8157: IOA error requiring IOA reset to recover"},
361 "ATA device status error"},
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"},
393 "Illegal request, invalid request type or request packet"},
395 "Illegal request, invalid resource handle"},
397 "Illegal request, commands not allowed to this device"},
399 "Illegal request, command not allowed to a secondary adapter"},
401 "Illegal request, command not allowed to a non-optimized resource"},
403 "Illegal request, invalid field in parameter list"},
405 "Illegal request, parameter not supported"},
407 "Illegal request, parameter value invalid"},
409 "Illegal request, command sequence error"},
411 "Illegal request, dual adapter support not enabled"},
413 "Illegal request, another cable connector was physically disabled"},
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"},
431 "FFFE: SCSI bus transition to single ended"},
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"},
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"},
537 "Data protect, other volume set problem"},
539 "Aborted command, invalid descriptor"},
541 "Target operating conditions have changed, dual adapter takeover"},
543 "Aborted command, medium removal prevented"},
545 "Command terminated by host"},
547 "Aborted command, command terminated by host"}
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 }
567 * Function Prototypes
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);
576 #ifdef CONFIG_SCSI_IPR_TRACE
578 * ipr_trc_hook - Add a trace entry to the driver trace
579 * @ipr_cmd: ipr command struct
581 * @add_data: additional data
586 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
587 u8 type, u32 add_data)
589 struct ipr_trace_entry *trace_entry;
590 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
591 unsigned int trace_index;
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;
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;
608 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
612 * ipr_lock_and_done - Acquire lock and complete command
613 * @ipr_cmd: ipr command struct
618 static void ipr_lock_and_done(struct ipr_cmnd *ipr_cmd)
620 unsigned long lock_flags;
621 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
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);
629 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
630 * @ipr_cmd: ipr command struct
635 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
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;
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;
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;
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;
662 ioasa->hdr.ioasc = 0;
663 ioasa->hdr.residual_data_len = 0;
664 ipr_cmd->scsi_cmd = NULL;
666 ipr_cmd->sense_buffer[0] = 0;
667 ipr_cmd->dma_use_sg = 0;
671 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
672 * @ipr_cmd: ipr command struct
673 * @fast_done: fast done function call-back
678 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd,
679 void (*fast_done) (struct ipr_cmnd *))
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);
690 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
694 * pointer to ipr command struct
697 struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq)
699 struct ipr_cmnd *ipr_cmd = NULL;
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);
712 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
713 * @ioa_cfg: ioa config struct
716 * pointer to ipr command struct
719 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
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);
728 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
729 * @ioa_cfg: ioa config struct
730 * @clr_ints: interrupts to clear
732 * This function masks all interrupts on the adapter, then clears the
733 * interrupts specified in the mask
738 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
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);
750 /* Set interrupt mask to stop all new interrupts */
752 writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
754 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
756 /* Clear any pending interrupts */
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);
764 * ipr_save_pcix_cmd_reg - Save PCI-X command register
765 * @ioa_cfg: ioa config struct
768 * 0 on success / -EIO on failure
770 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
772 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
774 if (pcix_cmd_reg == 0)
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");
783 ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
788 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
789 * @ioa_cfg: ioa config struct
792 * 0 on success / -EIO on failure
794 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
796 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
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");
810 * __ipr_sata_eh_done - done function for aborted SATA commands
811 * @ipr_cmd: ipr command struct
813 * This function is invoked for ops generated to SATA
814 * devices which are being aborted.
819 static void __ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
821 struct ata_queued_cmd *qc = ipr_cmd->qc;
822 struct ipr_sata_port *sata_port = qc->ap->private_data;
824 qc->err_mask |= AC_ERR_OTHER;
825 sata_port->ioasa.status |= ATA_BUSY;
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);
833 * ipr_sata_eh_done - done function for aborted SATA commands
834 * @ipr_cmd: ipr command struct
836 * This function is invoked for ops generated to SATA
837 * devices which are being aborted.
842 static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
844 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
845 unsigned long hrrq_flags;
847 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
848 __ipr_sata_eh_done(ipr_cmd);
849 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
853 * __ipr_scsi_eh_done - mid-layer done function for aborted ops
854 * @ipr_cmd: ipr command struct
856 * This function is invoked by the interrupt handler for
857 * ops generated by the SCSI mid-layer which are being aborted.
862 static void __ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
864 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
866 scsi_cmd->result |= (DID_ERROR << 16);
868 scsi_dma_unmap(ipr_cmd->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);
876 * ipr_scsi_eh_done - mid-layer done function for aborted ops
877 * @ipr_cmd: ipr command struct
879 * This function is invoked by the interrupt handler for
880 * ops generated by the SCSI mid-layer which are being aborted.
885 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
887 unsigned long hrrq_flags;
888 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
890 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
891 __ipr_scsi_eh_done(ipr_cmd);
892 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
896 * ipr_fail_all_ops - Fails all outstanding ops.
897 * @ioa_cfg: ioa config struct
899 * This function fails all outstanding ops.
904 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
906 struct ipr_cmnd *ipr_cmd, *temp;
907 struct ipr_hrr_queue *hrrq;
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);
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);
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;
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);
931 spin_unlock(&hrrq->_lock);
937 * ipr_send_command - Send driver initiated requests.
938 * @ipr_cmd: ipr command struct
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
947 static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
949 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
950 dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
952 if (ioa_cfg->sis64) {
953 /* The default size is 256 bytes */
954 send_dma_addr |= 0x1;
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);
962 writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
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
972 * This function sends the specified command to the adapter with the
973 * timeout given. The done function is invoked on command completion.
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)
982 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
984 ipr_cmd->done = done;
986 ipr_cmd->timer.expires = jiffies + timeout;
987 ipr_cmd->timer.function = timeout_func;
989 add_timer(&ipr_cmd->timer);
991 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
993 ipr_send_command(ipr_cmd);
997 * ipr_internal_cmd_done - Op done function for an internally generated op.
998 * @ipr_cmd: ipr command struct
1000 * This function is the op done function for an internally generated,
1001 * blocking op. It simply wakes the sleeping thread.
1006 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
1008 if (ipr_cmd->sibling)
1009 ipr_cmd->sibling = NULL;
1011 complete(&ipr_cmd->completion);
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
1021 * This function initializes an ioadl in the case where there is only a single
1027 static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
1030 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
1031 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
1033 ipr_cmd->dma_use_sg = 1;
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);
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);
1044 ioadl->flags_and_data_len = cpu_to_be32(flags | len);
1045 ioadl->address = cpu_to_be32(dma_addr);
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);
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);
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
1068 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
1069 void (*timeout_func) (struct timer_list *),
1072 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1074 init_completion(&ipr_cmd->completion);
1075 ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
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);
1082 static int ipr_get_hrrq_index(struct ipr_ioa_cfg *ioa_cfg)
1086 if (ioa_cfg->hrrq_num == 1)
1089 hrrq = atomic_add_return(1, &ioa_cfg->hrrq_index);
1090 hrrq = (hrrq % (ioa_cfg->hrrq_num - 1)) + 1;
1096 * ipr_send_hcam - Send an HCAM to the adapter.
1097 * @ioa_cfg: ioa config struct
1099 * @hostrcb: hostrcb struct
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.
1108 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
1109 struct ipr_hostrcb *hostrcb)
1111 struct ipr_cmnd *ipr_cmd;
1112 struct ipr_ioarcb *ioarcb;
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);
1119 ipr_cmd->u.hostrcb = hostrcb;
1120 ioarcb = &ipr_cmd->ioarcb;
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;
1129 ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
1130 sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
1132 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
1133 ipr_cmd->done = ipr_process_ccn;
1135 ipr_cmd->done = ipr_process_error;
1137 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
1139 ipr_send_command(ipr_cmd);
1141 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
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
1153 static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1156 case IPR_PROTO_SATA:
1157 case IPR_PROTO_SAS_STP:
1158 res->ata_class = ATA_DEV_ATA;
1160 case IPR_PROTO_SATA_ATAPI:
1161 case IPR_PROTO_SAS_STP_ATAPI:
1162 res->ata_class = ATA_DEV_ATAPI;
1165 res->ata_class = ATA_DEV_UNKNOWN;
1171 * ipr_init_res_entry - Initialize a resource entry struct.
1172 * @res: resource entry struct
1173 * @cfgtew: config table entry wrapper struct
1178 static void ipr_init_res_entry(struct ipr_resource_entry *res,
1179 struct ipr_config_table_entry_wrapper *cfgtew)
1183 struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1184 struct ipr_resource_entry *gscsi_res = NULL;
1186 res->needs_sync_complete = 0;
1189 res->del_from_ml = 0;
1190 res->resetting_device = 0;
1191 res->reset_occurred = 0;
1193 res->sata_port = NULL;
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;
1202 memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1203 sizeof(res->res_path));
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);
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) {
1214 res->target = gscsi_res->target;
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);
1223 } else if (res->type == IPR_RES_TYPE_IOAFP) {
1224 res->bus = IPR_IOAFP_VIRTUAL_BUS;
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);
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);
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;
1248 res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
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);
1256 ipr_update_ata_class(res, proto);
1260 * ipr_is_same_device - Determine if two devices are the same.
1261 * @res: resource entry struct
1262 * @cfgtew: config table entry wrapper struct
1265 * 1 if the devices are the same / 0 otherwise
1267 static int ipr_is_same_device(struct ipr_resource_entry *res,
1268 struct ipr_config_table_entry_wrapper *cfgtew)
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))) {
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)
1288 * __ipr_format_res_path - Format the resource path for printing.
1289 * @res_path: resource path
1291 * @len: length of buffer provided
1296 static char *__ipr_format_res_path(u8 *res_path, char *buffer, int len)
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]);
1310 * ipr_format_res_path - Format the resource path for printing.
1311 * @ioa_cfg: ioa config struct
1312 * @res_path: resource path
1314 * @len: length of buffer provided
1319 static char *ipr_format_res_path(struct ipr_ioa_cfg *ioa_cfg,
1320 u8 *res_path, char *buffer, int len)
1325 p += scnprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no);
1326 __ipr_format_res_path(res_path, p, len - (p - buffer));
1331 * ipr_update_res_entry - Update the resource entry.
1332 * @res: resource entry struct
1333 * @cfgtew: config table entry wrapper struct
1338 static void ipr_update_res_entry(struct ipr_resource_entry *res,
1339 struct ipr_config_table_entry_wrapper *cfgtew)
1341 char buffer[IPR_MAX_RES_PATH_LENGTH];
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;
1350 memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1351 sizeof(struct ipr_std_inq_data));
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;
1358 memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1359 sizeof(res->dev_lun.scsi_lun));
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));
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)));
1373 res->flags = cfgtew->u.cfgte->flags;
1374 if (res->flags & IPR_IS_IOA_RESOURCE)
1375 res->type = IPR_RES_TYPE_IOAFP;
1377 res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1379 memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1380 sizeof(struct ipr_std_inq_data));
1382 res->qmodel = IPR_QUEUEING_MODEL(res);
1383 proto = cfgtew->u.cfgte->proto;
1384 res->res_handle = cfgtew->u.cfgte->res_handle;
1387 ipr_update_ata_class(res, proto);
1391 * ipr_clear_res_target - Clear the bit in the bit map representing the target
1393 * @res: resource entry struct
1398 static void ipr_clear_res_target(struct ipr_resource_entry *res)
1400 struct ipr_resource_entry *gscsi_res = NULL;
1401 struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1403 if (!ioa_cfg->sis64)
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)
1414 clear_bit(res->target, ioa_cfg->target_ids);
1416 } else if (res->bus == 0)
1417 clear_bit(res->target, ioa_cfg->target_ids);
1421 * ipr_handle_config_change - Handle a config change from the adapter
1422 * @ioa_cfg: ioa config struct
1428 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1429 struct ipr_hostrcb *hostrcb)
1431 struct ipr_resource_entry *res = NULL;
1432 struct ipr_config_table_entry_wrapper cfgtew;
1433 __be32 cc_res_handle;
1437 if (ioa_cfg->sis64) {
1438 cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1439 cc_res_handle = cfgtew.u.cfgte64->res_handle;
1441 cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1442 cc_res_handle = cfgtew.u.cfgte->res_handle;
1445 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1446 if (res->res_handle == cc_res_handle) {
1453 if (list_empty(&ioa_cfg->free_res_q)) {
1454 ipr_send_hcam(ioa_cfg,
1455 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1460 res = list_entry(ioa_cfg->free_res_q.next,
1461 struct ipr_resource_entry, queue);
1463 list_del(&res->queue);
1464 ipr_init_res_entry(res, &cfgtew);
1465 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1468 ipr_update_res_entry(res, &cfgtew);
1470 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1472 res->del_from_ml = 1;
1473 res->res_handle = IPR_INVALID_RES_HANDLE;
1474 schedule_work(&ioa_cfg->work_q);
1476 ipr_clear_res_target(res);
1477 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1479 } else if (!res->sdev || res->del_from_ml) {
1481 schedule_work(&ioa_cfg->work_q);
1484 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1488 * ipr_process_ccn - Op done function for a CCN.
1489 * @ipr_cmd: ipr command struct
1491 * This function is the op done function for a configuration
1492 * change notification host controlled async from the adapter.
1497 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
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);
1503 list_del_init(&hostrcb->queue);
1504 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
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);
1512 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1514 ipr_handle_config_change(ioa_cfg, hostrcb);
1519 * strip_whitespace - Strip and pad trailing whitespace.
1520 * @i: size of buffer
1521 * @buf: string to modify
1523 * This function will strip all trailing whitespace and
1524 * NUL terminate the string.
1527 static void strip_whitespace(int i, char *buf)
1532 while (i && buf[i] == ' ')
1538 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1539 * @prefix: string to print at start of printk
1540 * @hostrcb: hostrcb pointer
1541 * @vpd: vendor/product id/sn struct
1546 static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1547 struct ipr_vpd *vpd)
1549 char vendor_id[IPR_VENDOR_ID_LEN + 1];
1550 char product_id[IPR_PROD_ID_LEN + 1];
1551 char sn[IPR_SERIAL_NUM_LEN + 1];
1553 memcpy(vendor_id, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1554 strip_whitespace(IPR_VENDOR_ID_LEN, vendor_id);
1556 memcpy(product_id, vpd->vpids.product_id, IPR_PROD_ID_LEN);
1557 strip_whitespace(IPR_PROD_ID_LEN, product_id);
1559 memcpy(sn, vpd->sn, IPR_SERIAL_NUM_LEN);
1560 strip_whitespace(IPR_SERIAL_NUM_LEN, sn);
1562 ipr_hcam_err(hostrcb, "%s VPID/SN: %s %s %s\n", prefix,
1563 vendor_id, product_id, sn);
1567 * ipr_log_vpd - Log the passed VPD to the error log.
1568 * @vpd: vendor/product id/sn struct
1573 static void ipr_log_vpd(struct ipr_vpd *vpd)
1575 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1576 + IPR_SERIAL_NUM_LEN];
1578 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1579 memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1581 buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1582 ipr_err("Vendor/Product ID: %s\n", buffer);
1584 memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1585 buffer[IPR_SERIAL_NUM_LEN] = '\0';
1586 ipr_err(" Serial Number: %s\n", buffer);
1590 * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1591 * @prefix: string to print at start of printk
1592 * @hostrcb: hostrcb pointer
1593 * @vpd: vendor/product id/sn/wwn struct
1598 static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1599 struct ipr_ext_vpd *vpd)
1601 ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1602 ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1603 be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1607 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1608 * @vpd: vendor/product id/sn/wwn struct
1613 static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1615 ipr_log_vpd(&vpd->vpd);
1616 ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1617 be32_to_cpu(vpd->wwid[1]));
1621 * ipr_log_enhanced_cache_error - Log a cache error.
1622 * @ioa_cfg: ioa config struct
1623 * @hostrcb: hostrcb struct
1628 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1629 struct ipr_hostrcb *hostrcb)
1631 struct ipr_hostrcb_type_12_error *error;
1634 error = &hostrcb->hcam.u.error64.u.type_12_error;
1636 error = &hostrcb->hcam.u.error.u.type_12_error;
1638 ipr_err("-----Current Configuration-----\n");
1639 ipr_err("Cache Directory Card Information:\n");
1640 ipr_log_ext_vpd(&error->ioa_vpd);
1641 ipr_err("Adapter Card Information:\n");
1642 ipr_log_ext_vpd(&error->cfc_vpd);
1644 ipr_err("-----Expected Configuration-----\n");
1645 ipr_err("Cache Directory Card Information:\n");
1646 ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1647 ipr_err("Adapter Card Information:\n");
1648 ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1650 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1651 be32_to_cpu(error->ioa_data[0]),
1652 be32_to_cpu(error->ioa_data[1]),
1653 be32_to_cpu(error->ioa_data[2]));
1657 * ipr_log_cache_error - Log a cache error.
1658 * @ioa_cfg: ioa config struct
1659 * @hostrcb: hostrcb struct
1664 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1665 struct ipr_hostrcb *hostrcb)
1667 struct ipr_hostrcb_type_02_error *error =
1668 &hostrcb->hcam.u.error.u.type_02_error;
1670 ipr_err("-----Current Configuration-----\n");
1671 ipr_err("Cache Directory Card Information:\n");
1672 ipr_log_vpd(&error->ioa_vpd);
1673 ipr_err("Adapter Card Information:\n");
1674 ipr_log_vpd(&error->cfc_vpd);
1676 ipr_err("-----Expected Configuration-----\n");
1677 ipr_err("Cache Directory Card Information:\n");
1678 ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1679 ipr_err("Adapter Card Information:\n");
1680 ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1682 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1683 be32_to_cpu(error->ioa_data[0]),
1684 be32_to_cpu(error->ioa_data[1]),
1685 be32_to_cpu(error->ioa_data[2]));
1689 * ipr_log_enhanced_config_error - Log a configuration error.
1690 * @ioa_cfg: ioa config struct
1691 * @hostrcb: hostrcb struct
1696 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1697 struct ipr_hostrcb *hostrcb)
1699 int errors_logged, i;
1700 struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1701 struct ipr_hostrcb_type_13_error *error;
1703 error = &hostrcb->hcam.u.error.u.type_13_error;
1704 errors_logged = be32_to_cpu(error->errors_logged);
1706 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1707 be32_to_cpu(error->errors_detected), errors_logged);
1709 dev_entry = error->dev;
1711 for (i = 0; i < errors_logged; i++, dev_entry++) {
1714 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1715 ipr_log_ext_vpd(&dev_entry->vpd);
1717 ipr_err("-----New Device Information-----\n");
1718 ipr_log_ext_vpd(&dev_entry->new_vpd);
1720 ipr_err("Cache Directory Card Information:\n");
1721 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1723 ipr_err("Adapter Card Information:\n");
1724 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1729 * ipr_log_sis64_config_error - Log a device error.
1730 * @ioa_cfg: ioa config struct
1731 * @hostrcb: hostrcb struct
1736 static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1737 struct ipr_hostrcb *hostrcb)
1739 int errors_logged, i;
1740 struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1741 struct ipr_hostrcb_type_23_error *error;
1742 char buffer[IPR_MAX_RES_PATH_LENGTH];
1744 error = &hostrcb->hcam.u.error64.u.type_23_error;
1745 errors_logged = be32_to_cpu(error->errors_logged);
1747 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1748 be32_to_cpu(error->errors_detected), errors_logged);
1750 dev_entry = error->dev;
1752 for (i = 0; i < errors_logged; i++, dev_entry++) {
1755 ipr_err("Device %d : %s", i + 1,
1756 __ipr_format_res_path(dev_entry->res_path,
1757 buffer, sizeof(buffer)));
1758 ipr_log_ext_vpd(&dev_entry->vpd);
1760 ipr_err("-----New Device Information-----\n");
1761 ipr_log_ext_vpd(&dev_entry->new_vpd);
1763 ipr_err("Cache Directory Card Information:\n");
1764 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1766 ipr_err("Adapter Card Information:\n");
1767 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1772 * ipr_log_config_error - Log a configuration error.
1773 * @ioa_cfg: ioa config struct
1774 * @hostrcb: hostrcb struct
1779 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1780 struct ipr_hostrcb *hostrcb)
1782 int errors_logged, i;
1783 struct ipr_hostrcb_device_data_entry *dev_entry;
1784 struct ipr_hostrcb_type_03_error *error;
1786 error = &hostrcb->hcam.u.error.u.type_03_error;
1787 errors_logged = be32_to_cpu(error->errors_logged);
1789 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1790 be32_to_cpu(error->errors_detected), errors_logged);
1792 dev_entry = error->dev;
1794 for (i = 0; i < errors_logged; i++, dev_entry++) {
1797 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1798 ipr_log_vpd(&dev_entry->vpd);
1800 ipr_err("-----New Device Information-----\n");
1801 ipr_log_vpd(&dev_entry->new_vpd);
1803 ipr_err("Cache Directory Card Information:\n");
1804 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1806 ipr_err("Adapter Card Information:\n");
1807 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1809 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1810 be32_to_cpu(dev_entry->ioa_data[0]),
1811 be32_to_cpu(dev_entry->ioa_data[1]),
1812 be32_to_cpu(dev_entry->ioa_data[2]),
1813 be32_to_cpu(dev_entry->ioa_data[3]),
1814 be32_to_cpu(dev_entry->ioa_data[4]));
1819 * ipr_log_enhanced_array_error - Log an array configuration error.
1820 * @ioa_cfg: ioa config struct
1821 * @hostrcb: hostrcb struct
1826 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1827 struct ipr_hostrcb *hostrcb)
1830 struct ipr_hostrcb_type_14_error *error;
1831 struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1832 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1834 error = &hostrcb->hcam.u.error.u.type_14_error;
1838 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1839 error->protection_level,
1840 ioa_cfg->host->host_no,
1841 error->last_func_vset_res_addr.bus,
1842 error->last_func_vset_res_addr.target,
1843 error->last_func_vset_res_addr.lun);
1847 array_entry = error->array_member;
1848 num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1849 ARRAY_SIZE(error->array_member));
1851 for (i = 0; i < num_entries; i++, array_entry++) {
1852 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1855 if (be32_to_cpu(error->exposed_mode_adn) == i)
1856 ipr_err("Exposed Array Member %d:\n", i);
1858 ipr_err("Array Member %d:\n", i);
1860 ipr_log_ext_vpd(&array_entry->vpd);
1861 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1862 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1863 "Expected Location");
1870 * ipr_log_array_error - Log an array configuration error.
1871 * @ioa_cfg: ioa config struct
1872 * @hostrcb: hostrcb struct
1877 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1878 struct ipr_hostrcb *hostrcb)
1881 struct ipr_hostrcb_type_04_error *error;
1882 struct ipr_hostrcb_array_data_entry *array_entry;
1883 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1885 error = &hostrcb->hcam.u.error.u.type_04_error;
1889 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1890 error->protection_level,
1891 ioa_cfg->host->host_no,
1892 error->last_func_vset_res_addr.bus,
1893 error->last_func_vset_res_addr.target,
1894 error->last_func_vset_res_addr.lun);
1898 array_entry = error->array_member;
1900 for (i = 0; i < 18; i++) {
1901 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1904 if (be32_to_cpu(error->exposed_mode_adn) == i)
1905 ipr_err("Exposed Array Member %d:\n", i);
1907 ipr_err("Array Member %d:\n", i);
1909 ipr_log_vpd(&array_entry->vpd);
1911 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1912 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1913 "Expected Location");
1918 array_entry = error->array_member2;
1925 * ipr_log_hex_data - Log additional hex IOA error data.
1926 * @ioa_cfg: ioa config struct
1927 * @data: IOA error data
1933 static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, __be32 *data, int len)
1940 if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1941 len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1943 for (i = 0; i < len / 4; i += 4) {
1944 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1945 be32_to_cpu(data[i]),
1946 be32_to_cpu(data[i+1]),
1947 be32_to_cpu(data[i+2]),
1948 be32_to_cpu(data[i+3]));
1953 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1954 * @ioa_cfg: ioa config struct
1955 * @hostrcb: hostrcb struct
1960 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1961 struct ipr_hostrcb *hostrcb)
1963 struct ipr_hostrcb_type_17_error *error;
1966 error = &hostrcb->hcam.u.error64.u.type_17_error;
1968 error = &hostrcb->hcam.u.error.u.type_17_error;
1970 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1971 strim(error->failure_reason);
1973 ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1974 be32_to_cpu(hostrcb->hcam.u.error.prc));
1975 ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1976 ipr_log_hex_data(ioa_cfg, error->data,
1977 be32_to_cpu(hostrcb->hcam.length) -
1978 (offsetof(struct ipr_hostrcb_error, u) +
1979 offsetof(struct ipr_hostrcb_type_17_error, data)));
1983 * ipr_log_dual_ioa_error - Log a dual adapter error.
1984 * @ioa_cfg: ioa config struct
1985 * @hostrcb: hostrcb struct
1990 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1991 struct ipr_hostrcb *hostrcb)
1993 struct ipr_hostrcb_type_07_error *error;
1995 error = &hostrcb->hcam.u.error.u.type_07_error;
1996 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1997 strim(error->failure_reason);
1999 ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
2000 be32_to_cpu(hostrcb->hcam.u.error.prc));
2001 ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
2002 ipr_log_hex_data(ioa_cfg, error->data,
2003 be32_to_cpu(hostrcb->hcam.length) -
2004 (offsetof(struct ipr_hostrcb_error, u) +
2005 offsetof(struct ipr_hostrcb_type_07_error, data)));
2008 static const struct {
2011 } path_active_desc[] = {
2012 { IPR_PATH_NO_INFO, "Path" },
2013 { IPR_PATH_ACTIVE, "Active path" },
2014 { IPR_PATH_NOT_ACTIVE, "Inactive path" }
2017 static const struct {
2020 } path_state_desc[] = {
2021 { IPR_PATH_STATE_NO_INFO, "has no path state information available" },
2022 { IPR_PATH_HEALTHY, "is healthy" },
2023 { IPR_PATH_DEGRADED, "is degraded" },
2024 { IPR_PATH_FAILED, "is failed" }
2028 * ipr_log_fabric_path - Log a fabric path error
2029 * @hostrcb: hostrcb struct
2030 * @fabric: fabric descriptor
2035 static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
2036 struct ipr_hostrcb_fabric_desc *fabric)
2039 u8 path_state = fabric->path_state;
2040 u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2041 u8 state = path_state & IPR_PATH_STATE_MASK;
2043 for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2044 if (path_active_desc[i].active != active)
2047 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2048 if (path_state_desc[j].state != state)
2051 if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
2052 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
2053 path_active_desc[i].desc, path_state_desc[j].desc,
2055 } else if (fabric->cascaded_expander == 0xff) {
2056 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
2057 path_active_desc[i].desc, path_state_desc[j].desc,
2058 fabric->ioa_port, fabric->phy);
2059 } else if (fabric->phy == 0xff) {
2060 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
2061 path_active_desc[i].desc, path_state_desc[j].desc,
2062 fabric->ioa_port, fabric->cascaded_expander);
2064 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
2065 path_active_desc[i].desc, path_state_desc[j].desc,
2066 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2072 ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
2073 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2077 * ipr_log64_fabric_path - Log a fabric path error
2078 * @hostrcb: hostrcb struct
2079 * @fabric: fabric descriptor
2084 static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
2085 struct ipr_hostrcb64_fabric_desc *fabric)
2088 u8 path_state = fabric->path_state;
2089 u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2090 u8 state = path_state & IPR_PATH_STATE_MASK;
2091 char buffer[IPR_MAX_RES_PATH_LENGTH];
2093 for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2094 if (path_active_desc[i].active != active)
2097 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2098 if (path_state_desc[j].state != state)
2101 ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
2102 path_active_desc[i].desc, path_state_desc[j].desc,
2103 ipr_format_res_path(hostrcb->ioa_cfg,
2105 buffer, sizeof(buffer)));
2110 ipr_err("Path state=%02X Resource Path=%s\n", path_state,
2111 ipr_format_res_path(hostrcb->ioa_cfg, fabric->res_path,
2112 buffer, sizeof(buffer)));
2115 static const struct {
2118 } path_type_desc[] = {
2119 { IPR_PATH_CFG_IOA_PORT, "IOA port" },
2120 { IPR_PATH_CFG_EXP_PORT, "Expander port" },
2121 { IPR_PATH_CFG_DEVICE_PORT, "Device port" },
2122 { IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
2125 static const struct {
2128 } path_status_desc[] = {
2129 { IPR_PATH_CFG_NO_PROB, "Functional" },
2130 { IPR_PATH_CFG_DEGRADED, "Degraded" },
2131 { IPR_PATH_CFG_FAILED, "Failed" },
2132 { IPR_PATH_CFG_SUSPECT, "Suspect" },
2133 { IPR_PATH_NOT_DETECTED, "Missing" },
2134 { IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
2137 static const char *link_rate[] = {
2140 "phy reset problem",
2157 * ipr_log_path_elem - Log a fabric path element.
2158 * @hostrcb: hostrcb struct
2159 * @cfg: fabric path element struct
2164 static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
2165 struct ipr_hostrcb_config_element *cfg)
2168 u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2169 u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2171 if (type == IPR_PATH_CFG_NOT_EXIST)
2174 for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2175 if (path_type_desc[i].type != type)
2178 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2179 if (path_status_desc[j].status != status)
2182 if (type == IPR_PATH_CFG_IOA_PORT) {
2183 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2184 path_status_desc[j].desc, path_type_desc[i].desc,
2185 cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2186 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2188 if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2189 ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2190 path_status_desc[j].desc, path_type_desc[i].desc,
2191 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2192 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2193 } else if (cfg->cascaded_expander == 0xff) {
2194 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2195 "WWN=%08X%08X\n", path_status_desc[j].desc,
2196 path_type_desc[i].desc, cfg->phy,
2197 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2198 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2199 } else if (cfg->phy == 0xff) {
2200 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2201 "WWN=%08X%08X\n", path_status_desc[j].desc,
2202 path_type_desc[i].desc, cfg->cascaded_expander,
2203 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2204 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2206 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2207 "WWN=%08X%08X\n", path_status_desc[j].desc,
2208 path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2209 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2210 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2217 ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2218 "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2219 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2220 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2224 * ipr_log64_path_elem - Log a fabric path element.
2225 * @hostrcb: hostrcb struct
2226 * @cfg: fabric path element struct
2231 static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2232 struct ipr_hostrcb64_config_element *cfg)
2235 u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2236 u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2237 u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2238 char buffer[IPR_MAX_RES_PATH_LENGTH];
2240 if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2243 for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2244 if (path_type_desc[i].type != type)
2247 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2248 if (path_status_desc[j].status != status)
2251 ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2252 path_status_desc[j].desc, path_type_desc[i].desc,
2253 ipr_format_res_path(hostrcb->ioa_cfg,
2254 cfg->res_path, buffer, sizeof(buffer)),
2255 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2256 be32_to_cpu(cfg->wwid[0]),
2257 be32_to_cpu(cfg->wwid[1]));
2261 ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2262 "WWN=%08X%08X\n", cfg->type_status,
2263 ipr_format_res_path(hostrcb->ioa_cfg,
2264 cfg->res_path, buffer, sizeof(buffer)),
2265 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2266 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2270 * ipr_log_fabric_error - Log a fabric error.
2271 * @ioa_cfg: ioa config struct
2272 * @hostrcb: hostrcb struct
2277 static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2278 struct ipr_hostrcb *hostrcb)
2280 struct ipr_hostrcb_type_20_error *error;
2281 struct ipr_hostrcb_fabric_desc *fabric;
2282 struct ipr_hostrcb_config_element *cfg;
2285 error = &hostrcb->hcam.u.error.u.type_20_error;
2286 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2287 ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2289 add_len = be32_to_cpu(hostrcb->hcam.length) -
2290 (offsetof(struct ipr_hostrcb_error, u) +
2291 offsetof(struct ipr_hostrcb_type_20_error, desc));
2293 for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2294 ipr_log_fabric_path(hostrcb, fabric);
2295 for_each_fabric_cfg(fabric, cfg)
2296 ipr_log_path_elem(hostrcb, cfg);
2298 add_len -= be16_to_cpu(fabric->length);
2299 fabric = (struct ipr_hostrcb_fabric_desc *)
2300 ((unsigned long)fabric + be16_to_cpu(fabric->length));
2303 ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2307 * ipr_log_sis64_array_error - Log a sis64 array error.
2308 * @ioa_cfg: ioa config struct
2309 * @hostrcb: hostrcb struct
2314 static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2315 struct ipr_hostrcb *hostrcb)
2318 struct ipr_hostrcb_type_24_error *error;
2319 struct ipr_hostrcb64_array_data_entry *array_entry;
2320 char buffer[IPR_MAX_RES_PATH_LENGTH];
2321 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2323 error = &hostrcb->hcam.u.error64.u.type_24_error;
2327 ipr_err("RAID %s Array Configuration: %s\n",
2328 error->protection_level,
2329 ipr_format_res_path(ioa_cfg, error->last_res_path,
2330 buffer, sizeof(buffer)));
2334 array_entry = error->array_member;
2335 num_entries = min_t(u32, error->num_entries,
2336 ARRAY_SIZE(error->array_member));
2338 for (i = 0; i < num_entries; i++, array_entry++) {
2340 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2343 if (error->exposed_mode_adn == i)
2344 ipr_err("Exposed Array Member %d:\n", i);
2346 ipr_err("Array Member %d:\n", i);
2348 ipr_err("Array Member %d:\n", i);
2349 ipr_log_ext_vpd(&array_entry->vpd);
2350 ipr_err("Current Location: %s\n",
2351 ipr_format_res_path(ioa_cfg, array_entry->res_path,
2352 buffer, sizeof(buffer)));
2353 ipr_err("Expected Location: %s\n",
2354 ipr_format_res_path(ioa_cfg,
2355 array_entry->expected_res_path,
2356 buffer, sizeof(buffer)));
2363 * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2364 * @ioa_cfg: ioa config struct
2365 * @hostrcb: hostrcb struct
2370 static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2371 struct ipr_hostrcb *hostrcb)
2373 struct ipr_hostrcb_type_30_error *error;
2374 struct ipr_hostrcb64_fabric_desc *fabric;
2375 struct ipr_hostrcb64_config_element *cfg;
2378 error = &hostrcb->hcam.u.error64.u.type_30_error;
2380 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2381 ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2383 add_len = be32_to_cpu(hostrcb->hcam.length) -
2384 (offsetof(struct ipr_hostrcb64_error, u) +
2385 offsetof(struct ipr_hostrcb_type_30_error, desc));
2387 for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2388 ipr_log64_fabric_path(hostrcb, fabric);
2389 for_each_fabric_cfg(fabric, cfg)
2390 ipr_log64_path_elem(hostrcb, cfg);
2392 add_len -= be16_to_cpu(fabric->length);
2393 fabric = (struct ipr_hostrcb64_fabric_desc *)
2394 ((unsigned long)fabric + be16_to_cpu(fabric->length));
2397 ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2401 * ipr_log_sis64_service_required_error - Log a sis64 service required error.
2402 * @ioa_cfg: ioa config struct
2403 * @hostrcb: hostrcb struct
2408 static void ipr_log_sis64_service_required_error(struct ipr_ioa_cfg *ioa_cfg,
2409 struct ipr_hostrcb *hostrcb)
2411 struct ipr_hostrcb_type_41_error *error;
2413 error = &hostrcb->hcam.u.error64.u.type_41_error;
2415 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2416 ipr_err("Primary Failure Reason: %s\n", error->failure_reason);
2417 ipr_log_hex_data(ioa_cfg, error->data,
2418 be32_to_cpu(hostrcb->hcam.length) -
2419 (offsetof(struct ipr_hostrcb_error, u) +
2420 offsetof(struct ipr_hostrcb_type_41_error, data)));
2423 * ipr_log_generic_error - Log an adapter error.
2424 * @ioa_cfg: ioa config struct
2425 * @hostrcb: hostrcb struct
2430 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2431 struct ipr_hostrcb *hostrcb)
2433 ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2434 be32_to_cpu(hostrcb->hcam.length));
2438 * ipr_log_sis64_device_error - Log a cache error.
2439 * @ioa_cfg: ioa config struct
2440 * @hostrcb: hostrcb struct
2445 static void ipr_log_sis64_device_error(struct ipr_ioa_cfg *ioa_cfg,
2446 struct ipr_hostrcb *hostrcb)
2448 struct ipr_hostrcb_type_21_error *error;
2449 char buffer[IPR_MAX_RES_PATH_LENGTH];
2451 error = &hostrcb->hcam.u.error64.u.type_21_error;
2453 ipr_err("-----Failing Device Information-----\n");
2454 ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
2455 be32_to_cpu(error->wwn[0]), be32_to_cpu(error->wwn[1]),
2456 be32_to_cpu(error->wwn[2]), be32_to_cpu(error->wwn[3]));
2457 ipr_err("Device Resource Path: %s\n",
2458 __ipr_format_res_path(error->res_path,
2459 buffer, sizeof(buffer)));
2460 error->primary_problem_desc[sizeof(error->primary_problem_desc) - 1] = '\0';
2461 error->second_problem_desc[sizeof(error->second_problem_desc) - 1] = '\0';
2462 ipr_err("Primary Problem Description: %s\n", error->primary_problem_desc);
2463 ipr_err("Secondary Problem Description: %s\n", error->second_problem_desc);
2464 ipr_err("SCSI Sense Data:\n");
2465 ipr_log_hex_data(ioa_cfg, error->sense_data, sizeof(error->sense_data));
2466 ipr_err("SCSI Command Descriptor Block: \n");
2467 ipr_log_hex_data(ioa_cfg, error->cdb, sizeof(error->cdb));
2469 ipr_err("Additional IOA Data:\n");
2470 ipr_log_hex_data(ioa_cfg, error->ioa_data, be32_to_cpu(error->length_of_error));
2474 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2477 * This function will return the index of into the ipr_error_table
2478 * for the specified IOASC. If the IOASC is not in the table,
2479 * 0 will be returned, which points to the entry used for unknown errors.
2482 * index into the ipr_error_table
2484 static u32 ipr_get_error(u32 ioasc)
2488 for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2489 if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2496 * ipr_handle_log_data - Log an adapter error.
2497 * @ioa_cfg: ioa config struct
2498 * @hostrcb: hostrcb struct
2500 * This function logs an adapter error to the system.
2505 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2506 struct ipr_hostrcb *hostrcb)
2510 struct ipr_hostrcb_type_21_error *error;
2512 if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2515 if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2516 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2519 ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2521 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2523 if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2524 ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2525 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2526 scsi_report_bus_reset(ioa_cfg->host,
2527 hostrcb->hcam.u.error.fd_res_addr.bus);
2530 error_index = ipr_get_error(ioasc);
2532 if (!ipr_error_table[error_index].log_hcam)
2535 if (ioasc == IPR_IOASC_HW_CMD_FAILED &&
2536 hostrcb->hcam.overlay_id == IPR_HOST_RCB_OVERLAY_ID_21) {
2537 error = &hostrcb->hcam.u.error64.u.type_21_error;
2539 if (((be32_to_cpu(error->sense_data[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST &&
2540 ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
2544 ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2546 /* Set indication we have logged an error */
2547 ioa_cfg->errors_logged++;
2549 if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2551 if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2552 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2554 switch (hostrcb->hcam.overlay_id) {
2555 case IPR_HOST_RCB_OVERLAY_ID_2:
2556 ipr_log_cache_error(ioa_cfg, hostrcb);
2558 case IPR_HOST_RCB_OVERLAY_ID_3:
2559 ipr_log_config_error(ioa_cfg, hostrcb);
2561 case IPR_HOST_RCB_OVERLAY_ID_4:
2562 case IPR_HOST_RCB_OVERLAY_ID_6:
2563 ipr_log_array_error(ioa_cfg, hostrcb);
2565 case IPR_HOST_RCB_OVERLAY_ID_7:
2566 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2568 case IPR_HOST_RCB_OVERLAY_ID_12:
2569 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2571 case IPR_HOST_RCB_OVERLAY_ID_13:
2572 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2574 case IPR_HOST_RCB_OVERLAY_ID_14:
2575 case IPR_HOST_RCB_OVERLAY_ID_16:
2576 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2578 case IPR_HOST_RCB_OVERLAY_ID_17:
2579 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2581 case IPR_HOST_RCB_OVERLAY_ID_20:
2582 ipr_log_fabric_error(ioa_cfg, hostrcb);
2584 case IPR_HOST_RCB_OVERLAY_ID_21:
2585 ipr_log_sis64_device_error(ioa_cfg, hostrcb);
2587 case IPR_HOST_RCB_OVERLAY_ID_23:
2588 ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2590 case IPR_HOST_RCB_OVERLAY_ID_24:
2591 case IPR_HOST_RCB_OVERLAY_ID_26:
2592 ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2594 case IPR_HOST_RCB_OVERLAY_ID_30:
2595 ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2597 case IPR_HOST_RCB_OVERLAY_ID_41:
2598 ipr_log_sis64_service_required_error(ioa_cfg, hostrcb);
2600 case IPR_HOST_RCB_OVERLAY_ID_1:
2601 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2603 ipr_log_generic_error(ioa_cfg, hostrcb);
2608 static struct ipr_hostrcb *ipr_get_free_hostrcb(struct ipr_ioa_cfg *ioa)
2610 struct ipr_hostrcb *hostrcb;
2612 hostrcb = list_first_entry_or_null(&ioa->hostrcb_free_q,
2613 struct ipr_hostrcb, queue);
2615 if (unlikely(!hostrcb)) {
2616 dev_info(&ioa->pdev->dev, "Reclaiming async error buffers.");
2617 hostrcb = list_first_entry_or_null(&ioa->hostrcb_report_q,
2618 struct ipr_hostrcb, queue);
2621 list_del_init(&hostrcb->queue);
2626 * ipr_process_error - Op done function for an adapter error log.
2627 * @ipr_cmd: ipr command struct
2629 * This function is the op done function for an error log host
2630 * controlled async from the adapter. It will log the error and
2631 * send the HCAM back to the adapter.
2636 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2638 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2639 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2640 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2644 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2646 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2648 list_del_init(&hostrcb->queue);
2649 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
2652 ipr_handle_log_data(ioa_cfg, hostrcb);
2653 if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2654 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2655 } else if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
2656 ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) {
2657 dev_err(&ioa_cfg->pdev->dev,
2658 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
2661 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_report_q);
2662 schedule_work(&ioa_cfg->work_q);
2663 hostrcb = ipr_get_free_hostrcb(ioa_cfg);
2665 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2669 * ipr_timeout - An internally generated op has timed out.
2670 * @t: Timer context used to fetch ipr command struct
2672 * This function blocks host requests and initiates an
2678 static void ipr_timeout(struct timer_list *t)
2680 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2681 unsigned long lock_flags = 0;
2682 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2685 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2687 ioa_cfg->errors_logged++;
2688 dev_err(&ioa_cfg->pdev->dev,
2689 "Adapter being reset due to command timeout.\n");
2691 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2692 ioa_cfg->sdt_state = GET_DUMP;
2694 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2695 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2697 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2702 * ipr_oper_timeout - Adapter timed out transitioning to operational
2703 * @t: Timer context used to fetch ipr command struct
2705 * This function blocks host requests and initiates an
2711 static void ipr_oper_timeout(struct timer_list *t)
2713 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2714 unsigned long lock_flags = 0;
2715 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2718 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2720 ioa_cfg->errors_logged++;
2721 dev_err(&ioa_cfg->pdev->dev,
2722 "Adapter timed out transitioning to operational.\n");
2724 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2725 ioa_cfg->sdt_state = GET_DUMP;
2727 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2729 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2730 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2733 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2738 * ipr_find_ses_entry - Find matching SES in SES table
2739 * @res: resource entry struct of SES
2742 * pointer to SES table entry / NULL on failure
2744 static const struct ipr_ses_table_entry *
2745 ipr_find_ses_entry(struct ipr_resource_entry *res)
2748 struct ipr_std_inq_vpids *vpids;
2749 const struct ipr_ses_table_entry *ste = ipr_ses_table;
2751 for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2752 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2753 if (ste->compare_product_id_byte[j] == 'X') {
2754 vpids = &res->std_inq_data.vpids;
2755 if (vpids->product_id[j] == ste->product_id[j])
2763 if (matches == IPR_PROD_ID_LEN)
2771 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2772 * @ioa_cfg: ioa config struct
2774 * @bus_width: bus width
2777 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2778 * For a 2-byte wide SCSI bus, the maximum transfer speed is
2779 * twice the maximum transfer rate (e.g. for a wide enabled bus,
2780 * max 160MHz = max 320MB/sec).
2782 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2784 struct ipr_resource_entry *res;
2785 const struct ipr_ses_table_entry *ste;
2786 u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2788 /* Loop through each config table entry in the config table buffer */
2789 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2790 if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2793 if (bus != res->bus)
2796 if (!(ste = ipr_find_ses_entry(res)))
2799 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2802 return max_xfer_rate;
2806 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2807 * @ioa_cfg: ioa config struct
2808 * @max_delay: max delay in micro-seconds to wait
2810 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2813 * 0 on success / other on failure
2815 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2817 volatile u32 pcii_reg;
2820 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2821 while (delay < max_delay) {
2822 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2824 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2827 /* udelay cannot be used if delay is more than a few milliseconds */
2828 if ((delay / 1000) > MAX_UDELAY_MS)
2829 mdelay(delay / 1000);
2839 * ipr_get_sis64_dump_data_section - Dump IOA memory
2840 * @ioa_cfg: ioa config struct
2841 * @start_addr: adapter address to dump
2842 * @dest: destination kernel buffer
2843 * @length_in_words: length to dump in 4 byte words
2848 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2850 __be32 *dest, u32 length_in_words)
2854 for (i = 0; i < length_in_words; i++) {
2855 writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2856 *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2864 * ipr_get_ldump_data_section - Dump IOA memory
2865 * @ioa_cfg: ioa config struct
2866 * @start_addr: adapter address to dump
2867 * @dest: destination kernel buffer
2868 * @length_in_words: length to dump in 4 byte words
2871 * 0 on success / -EIO on failure
2873 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2875 __be32 *dest, u32 length_in_words)
2877 volatile u32 temp_pcii_reg;
2881 return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2882 dest, length_in_words);
2884 /* Write IOA interrupt reg starting LDUMP state */
2885 writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2886 ioa_cfg->regs.set_uproc_interrupt_reg32);
2888 /* Wait for IO debug acknowledge */
2889 if (ipr_wait_iodbg_ack(ioa_cfg,
2890 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2891 dev_err(&ioa_cfg->pdev->dev,
2892 "IOA dump long data transfer timeout\n");
2896 /* Signal LDUMP interlocked - clear IO debug ack */
2897 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2898 ioa_cfg->regs.clr_interrupt_reg);
2900 /* Write Mailbox with starting address */
2901 writel(start_addr, ioa_cfg->ioa_mailbox);
2903 /* Signal address valid - clear IOA Reset alert */
2904 writel(IPR_UPROCI_RESET_ALERT,
2905 ioa_cfg->regs.clr_uproc_interrupt_reg32);
2907 for (i = 0; i < length_in_words; i++) {
2908 /* Wait for IO debug acknowledge */
2909 if (ipr_wait_iodbg_ack(ioa_cfg,
2910 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2911 dev_err(&ioa_cfg->pdev->dev,
2912 "IOA dump short data transfer timeout\n");
2916 /* Read data from mailbox and increment destination pointer */
2917 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2920 /* For all but the last word of data, signal data received */
2921 if (i < (length_in_words - 1)) {
2922 /* Signal dump data received - Clear IO debug Ack */
2923 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2924 ioa_cfg->regs.clr_interrupt_reg);
2928 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2929 writel(IPR_UPROCI_RESET_ALERT,
2930 ioa_cfg->regs.set_uproc_interrupt_reg32);
2932 writel(IPR_UPROCI_IO_DEBUG_ALERT,
2933 ioa_cfg->regs.clr_uproc_interrupt_reg32);
2935 /* Signal dump data received - Clear IO debug Ack */
2936 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2937 ioa_cfg->regs.clr_interrupt_reg);
2939 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2940 while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2942 readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2944 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2954 #ifdef CONFIG_SCSI_IPR_DUMP
2956 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2957 * @ioa_cfg: ioa config struct
2958 * @pci_address: adapter address
2959 * @length: length of data to copy
2961 * Copy data from PCI adapter to kernel buffer.
2962 * Note: length MUST be a 4 byte multiple
2964 * 0 on success / other on failure
2966 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2967 unsigned long pci_address, u32 length)
2969 int bytes_copied = 0;
2970 int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2972 unsigned long lock_flags = 0;
2973 struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2976 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2978 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2980 while (bytes_copied < length &&
2981 (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2982 if (ioa_dump->page_offset >= PAGE_SIZE ||
2983 ioa_dump->page_offset == 0) {
2984 page = (__be32 *)__get_free_page(GFP_ATOMIC);
2988 return bytes_copied;
2991 ioa_dump->page_offset = 0;
2992 ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2993 ioa_dump->next_page_index++;
2995 page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2997 rem_len = length - bytes_copied;
2998 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2999 cur_len = min(rem_len, rem_page_len);
3001 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3002 if (ioa_cfg->sdt_state == ABORT_DUMP) {
3005 rc = ipr_get_ldump_data_section(ioa_cfg,
3006 pci_address + bytes_copied,
3007 &page[ioa_dump->page_offset / 4],
3008 (cur_len / sizeof(u32)));
3010 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3013 ioa_dump->page_offset += cur_len;
3014 bytes_copied += cur_len;
3022 return bytes_copied;
3026 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
3027 * @hdr: dump entry header struct
3032 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
3034 hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
3036 hdr->offset = sizeof(*hdr);
3037 hdr->status = IPR_DUMP_STATUS_SUCCESS;
3041 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
3042 * @ioa_cfg: ioa config struct
3043 * @driver_dump: driver dump struct
3048 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
3049 struct ipr_driver_dump *driver_dump)
3051 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3053 ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
3054 driver_dump->ioa_type_entry.hdr.len =
3055 sizeof(struct ipr_dump_ioa_type_entry) -
3056 sizeof(struct ipr_dump_entry_header);
3057 driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3058 driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
3059 driver_dump->ioa_type_entry.type = ioa_cfg->type;
3060 driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
3061 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
3062 ucode_vpd->minor_release[1];
3063 driver_dump->hdr.num_entries++;
3067 * ipr_dump_version_data - Fill in the driver version in the dump.
3068 * @ioa_cfg: ioa config struct
3069 * @driver_dump: driver dump struct
3074 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
3075 struct ipr_driver_dump *driver_dump)
3077 ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
3078 driver_dump->version_entry.hdr.len =
3079 sizeof(struct ipr_dump_version_entry) -
3080 sizeof(struct ipr_dump_entry_header);
3081 driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3082 driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
3083 strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
3084 driver_dump->hdr.num_entries++;
3088 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
3089 * @ioa_cfg: ioa config struct
3090 * @driver_dump: driver dump struct
3095 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
3096 struct ipr_driver_dump *driver_dump)
3098 ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
3099 driver_dump->trace_entry.hdr.len =
3100 sizeof(struct ipr_dump_trace_entry) -
3101 sizeof(struct ipr_dump_entry_header);
3102 driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3103 driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
3104 memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
3105 driver_dump->hdr.num_entries++;
3109 * ipr_dump_location_data - Fill in the IOA location in the dump.
3110 * @ioa_cfg: ioa config struct
3111 * @driver_dump: driver dump struct
3116 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
3117 struct ipr_driver_dump *driver_dump)
3119 ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
3120 driver_dump->location_entry.hdr.len =
3121 sizeof(struct ipr_dump_location_entry) -
3122 sizeof(struct ipr_dump_entry_header);
3123 driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3124 driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
3125 strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
3126 driver_dump->hdr.num_entries++;
3130 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
3131 * @ioa_cfg: ioa config struct
3132 * @dump: dump struct
3137 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
3139 unsigned long start_addr, sdt_word;
3140 unsigned long lock_flags = 0;
3141 struct ipr_driver_dump *driver_dump = &dump->driver_dump;
3142 struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
3143 u32 num_entries, max_num_entries, start_off, end_off;
3144 u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
3145 struct ipr_sdt *sdt;
3151 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3153 if (ioa_cfg->sdt_state != READ_DUMP) {
3154 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3158 if (ioa_cfg->sis64) {
3159 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3160 ssleep(IPR_DUMP_DELAY_SECONDS);
3161 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3164 start_addr = readl(ioa_cfg->ioa_mailbox);
3166 if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
3167 dev_err(&ioa_cfg->pdev->dev,
3168 "Invalid dump table format: %lx\n", start_addr);
3169 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3173 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
3175 driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
3177 /* Initialize the overall dump header */
3178 driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
3179 driver_dump->hdr.num_entries = 1;
3180 driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
3181 driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
3182 driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
3183 driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
3185 ipr_dump_version_data(ioa_cfg, driver_dump);
3186 ipr_dump_location_data(ioa_cfg, driver_dump);
3187 ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
3188 ipr_dump_trace_data(ioa_cfg, driver_dump);
3190 /* Update dump_header */
3191 driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
3193 /* IOA Dump entry */
3194 ipr_init_dump_entry_hdr(&ioa_dump->hdr);
3195 ioa_dump->hdr.len = 0;
3196 ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3197 ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
3199 /* First entries in sdt are actually a list of dump addresses and
3200 lengths to gather the real dump data. sdt represents the pointer
3201 to the ioa generated dump table. Dump data will be extracted based
3202 on entries in this table */
3203 sdt = &ioa_dump->sdt;
3205 if (ioa_cfg->sis64) {
3206 max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
3207 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
3209 max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
3210 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
3213 bytes_to_copy = offsetof(struct ipr_sdt, entry) +
3214 (max_num_entries * sizeof(struct ipr_sdt_entry));
3215 rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
3216 bytes_to_copy / sizeof(__be32));
3218 /* Smart Dump table is ready to use and the first entry is valid */
3219 if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
3220 (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
3221 dev_err(&ioa_cfg->pdev->dev,
3222 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
3223 rc, be32_to_cpu(sdt->hdr.state));
3224 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
3225 ioa_cfg->sdt_state = DUMP_OBTAINED;
3226 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3230 num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
3232 if (num_entries > max_num_entries)
3233 num_entries = max_num_entries;
3235 /* Update dump length to the actual data to be copied */
3236 dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
3238 dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
3240 dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
3242 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3244 for (i = 0; i < num_entries; i++) {
3245 if (ioa_dump->hdr.len > max_dump_size) {
3246 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3250 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3251 sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3253 bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3255 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3256 end_off = be32_to_cpu(sdt->entry[i].end_token);
3258 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3259 bytes_to_copy = end_off - start_off;
3264 if (bytes_to_copy > max_dump_size) {
3265 sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3269 /* Copy data from adapter to driver buffers */
3270 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3273 ioa_dump->hdr.len += bytes_copied;
3275 if (bytes_copied != bytes_to_copy) {
3276 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3283 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3285 /* Update dump_header */
3286 driver_dump->hdr.len += ioa_dump->hdr.len;
3288 ioa_cfg->sdt_state = DUMP_OBTAINED;
3293 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3297 * ipr_release_dump - Free adapter dump memory
3298 * @kref: kref struct
3303 static void ipr_release_dump(struct kref *kref)
3305 struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3306 struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3307 unsigned long lock_flags = 0;
3311 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3312 ioa_cfg->dump = NULL;
3313 ioa_cfg->sdt_state = INACTIVE;
3314 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3316 for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3317 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3319 vfree(dump->ioa_dump.ioa_data);
3324 static void ipr_add_remove_thread(struct work_struct *work)
3326 unsigned long lock_flags;
3327 struct ipr_resource_entry *res;
3328 struct scsi_device *sdev;
3329 struct ipr_ioa_cfg *ioa_cfg =
3330 container_of(work, struct ipr_ioa_cfg, scsi_add_work_q);
3331 u8 bus, target, lun;
3335 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3340 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
3341 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3345 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3346 if (res->del_from_ml && res->sdev) {
3349 if (!scsi_device_get(sdev)) {
3350 if (!res->add_to_ml)
3351 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3353 res->del_from_ml = 0;
3354 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3355 scsi_remove_device(sdev);
3356 scsi_device_put(sdev);
3357 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3364 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3365 if (res->add_to_ml) {
3367 target = res->target;
3370 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3371 scsi_add_device(ioa_cfg->host, bus, target, lun);
3372 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3377 ioa_cfg->scan_done = 1;
3378 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3379 kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3384 * ipr_worker_thread - Worker thread
3385 * @work: ioa config struct
3387 * Called at task level from a work thread. This function takes care
3388 * of adding and removing device from the mid-layer as configuration
3389 * changes are detected by the adapter.
3394 static void ipr_worker_thread(struct work_struct *work)
3396 unsigned long lock_flags;
3397 struct ipr_dump *dump;
3398 struct ipr_ioa_cfg *ioa_cfg =
3399 container_of(work, struct ipr_ioa_cfg, work_q);
3402 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3404 if (ioa_cfg->sdt_state == READ_DUMP) {
3405 dump = ioa_cfg->dump;
3407 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3410 kref_get(&dump->kref);
3411 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3412 ipr_get_ioa_dump(ioa_cfg, dump);
3413 kref_put(&dump->kref, ipr_release_dump);
3415 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3416 if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3417 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3418 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3422 if (ioa_cfg->scsi_unblock) {
3423 ioa_cfg->scsi_unblock = 0;
3424 ioa_cfg->scsi_blocked = 0;
3425 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3426 scsi_unblock_requests(ioa_cfg->host);
3427 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3428 if (ioa_cfg->scsi_blocked)
3429 scsi_block_requests(ioa_cfg->host);
3432 if (!ioa_cfg->scan_enabled) {
3433 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3437 schedule_work(&ioa_cfg->scsi_add_work_q);
3439 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3443 #ifdef CONFIG_SCSI_IPR_TRACE
3445 * ipr_read_trace - Dump the adapter trace
3446 * @filp: open sysfs file
3447 * @kobj: kobject struct
3448 * @bin_attr: bin_attribute struct
3451 * @count: buffer size
3454 * number of bytes printed to buffer
3456 static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3457 struct bin_attribute *bin_attr,
3458 char *buf, loff_t off, size_t count)
3460 struct device *dev = kobj_to_dev(kobj);
3461 struct Scsi_Host *shost = class_to_shost(dev);
3462 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3463 unsigned long lock_flags = 0;
3466 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3467 ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3469 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3474 static struct bin_attribute ipr_trace_attr = {
3480 .read = ipr_read_trace,
3485 * ipr_show_fw_version - Show the firmware version
3486 * @dev: class device struct
3487 * @attr: device attribute (unused)
3491 * number of bytes printed to buffer
3493 static ssize_t ipr_show_fw_version(struct device *dev,
3494 struct device_attribute *attr, char *buf)
3496 struct Scsi_Host *shost = class_to_shost(dev);
3497 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3498 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3499 unsigned long lock_flags = 0;
3502 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3503 len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3504 ucode_vpd->major_release, ucode_vpd->card_type,
3505 ucode_vpd->minor_release[0],
3506 ucode_vpd->minor_release[1]);
3507 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3511 static struct device_attribute ipr_fw_version_attr = {
3513 .name = "fw_version",
3516 .show = ipr_show_fw_version,
3520 * ipr_show_log_level - Show the adapter's error logging level
3521 * @dev: class device struct
3522 * @attr: device attribute (unused)
3526 * number of bytes printed to buffer
3528 static ssize_t ipr_show_log_level(struct device *dev,
3529 struct device_attribute *attr, char *buf)
3531 struct Scsi_Host *shost = class_to_shost(dev);
3532 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3533 unsigned long lock_flags = 0;
3536 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3537 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3538 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3543 * ipr_store_log_level - Change the adapter's error logging level
3544 * @dev: class device struct
3545 * @attr: device attribute (unused)
3547 * @count: buffer size
3550 * number of bytes printed to buffer
3552 static ssize_t ipr_store_log_level(struct device *dev,
3553 struct device_attribute *attr,
3554 const char *buf, size_t count)
3556 struct Scsi_Host *shost = class_to_shost(dev);
3557 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3558 unsigned long lock_flags = 0;
3560 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3561 ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3562 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3566 static struct device_attribute ipr_log_level_attr = {
3568 .name = "log_level",
3569 .mode = S_IRUGO | S_IWUSR,
3571 .show = ipr_show_log_level,
3572 .store = ipr_store_log_level
3576 * ipr_store_diagnostics - IOA Diagnostics interface
3577 * @dev: device struct
3578 * @attr: device attribute (unused)
3580 * @count: buffer size
3582 * This function will reset the adapter and wait a reasonable
3583 * amount of time for any errors that the adapter might log.
3586 * count on success / other on failure
3588 static ssize_t ipr_store_diagnostics(struct device *dev,
3589 struct device_attribute *attr,
3590 const char *buf, size_t count)
3592 struct Scsi_Host *shost = class_to_shost(dev);
3593 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3594 unsigned long lock_flags = 0;
3597 if (!capable(CAP_SYS_ADMIN))
3600 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3601 while (ioa_cfg->in_reset_reload) {
3602 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3603 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3604 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3607 ioa_cfg->errors_logged = 0;
3608 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3610 if (ioa_cfg->in_reset_reload) {
3611 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3612 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3614 /* Wait for a second for any errors to be logged */
3617 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3621 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3622 if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3624 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3629 static struct device_attribute ipr_diagnostics_attr = {
3631 .name = "run_diagnostics",
3634 .store = ipr_store_diagnostics
3638 * ipr_show_adapter_state - Show the adapter's state
3639 * @dev: device struct
3640 * @attr: device attribute (unused)
3644 * number of bytes printed to buffer
3646 static ssize_t ipr_show_adapter_state(struct device *dev,
3647 struct device_attribute *attr, char *buf)
3649 struct Scsi_Host *shost = class_to_shost(dev);
3650 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3651 unsigned long lock_flags = 0;
3654 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3655 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
3656 len = snprintf(buf, PAGE_SIZE, "offline\n");
3658 len = snprintf(buf, PAGE_SIZE, "online\n");
3659 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3664 * ipr_store_adapter_state - Change adapter state
3665 * @dev: device struct
3666 * @attr: device attribute (unused)
3668 * @count: buffer size
3670 * This function will change the adapter's state.
3673 * count on success / other on failure
3675 static ssize_t ipr_store_adapter_state(struct device *dev,
3676 struct device_attribute *attr,
3677 const char *buf, size_t count)
3679 struct Scsi_Host *shost = class_to_shost(dev);
3680 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3681 unsigned long lock_flags;
3682 int result = count, i;
3684 if (!capable(CAP_SYS_ADMIN))
3687 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3688 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead &&
3689 !strncmp(buf, "online", 6)) {
3690 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
3691 spin_lock(&ioa_cfg->hrrq[i]._lock);
3692 ioa_cfg->hrrq[i].ioa_is_dead = 0;
3693 spin_unlock(&ioa_cfg->hrrq[i]._lock);
3696 ioa_cfg->reset_retries = 0;
3697 ioa_cfg->in_ioa_bringdown = 0;
3698 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3700 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3701 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3706 static struct device_attribute ipr_ioa_state_attr = {
3708 .name = "online_state",
3709 .mode = S_IRUGO | S_IWUSR,
3711 .show = ipr_show_adapter_state,
3712 .store = ipr_store_adapter_state
3716 * ipr_store_reset_adapter - Reset the adapter
3717 * @dev: device struct
3718 * @attr: device attribute (unused)
3720 * @count: buffer size
3722 * This function will reset the adapter.
3725 * count on success / other on failure
3727 static ssize_t ipr_store_reset_adapter(struct device *dev,
3728 struct device_attribute *attr,
3729 const char *buf, size_t count)
3731 struct Scsi_Host *shost = class_to_shost(dev);
3732 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3733 unsigned long lock_flags;
3736 if (!capable(CAP_SYS_ADMIN))
3739 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3740 if (!ioa_cfg->in_reset_reload)
3741 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3742 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3743 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3748 static struct device_attribute ipr_ioa_reset_attr = {
3750 .name = "reset_host",
3753 .store = ipr_store_reset_adapter
3756 static int ipr_iopoll(struct irq_poll *iop, int budget);
3758 * ipr_show_iopoll_weight - Show ipr polling mode
3759 * @dev: class device struct
3760 * @attr: device attribute (unused)
3764 * number of bytes printed to buffer
3766 static ssize_t ipr_show_iopoll_weight(struct device *dev,
3767 struct device_attribute *attr, char *buf)
3769 struct Scsi_Host *shost = class_to_shost(dev);
3770 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3771 unsigned long lock_flags = 0;
3774 spin_lock_irqsave(shost->host_lock, lock_flags);
3775 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight);
3776 spin_unlock_irqrestore(shost->host_lock, lock_flags);
3782 * ipr_store_iopoll_weight - Change the adapter's polling mode
3783 * @dev: class device struct
3784 * @attr: device attribute (unused)
3786 * @count: buffer size
3789 * number of bytes printed to buffer
3791 static ssize_t ipr_store_iopoll_weight(struct device *dev,
3792 struct device_attribute *attr,
3793 const char *buf, size_t count)
3795 struct Scsi_Host *shost = class_to_shost(dev);
3796 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3797 unsigned long user_iopoll_weight;
3798 unsigned long lock_flags = 0;
3801 if (!ioa_cfg->sis64) {
3802 dev_info(&ioa_cfg->pdev->dev, "irq_poll not supported on this adapter\n");
3805 if (kstrtoul(buf, 10, &user_iopoll_weight))
3808 if (user_iopoll_weight > 256) {
3809 dev_info(&ioa_cfg->pdev->dev, "Invalid irq_poll weight. It must be less than 256\n");
3813 if (user_iopoll_weight == ioa_cfg->iopoll_weight) {
3814 dev_info(&ioa_cfg->pdev->dev, "Current irq_poll weight has the same weight\n");
3818 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3819 for (i = 1; i < ioa_cfg->hrrq_num; i++)
3820 irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
3823 spin_lock_irqsave(shost->host_lock, lock_flags);
3824 ioa_cfg->iopoll_weight = user_iopoll_weight;
3825 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3826 for (i = 1; i < ioa_cfg->hrrq_num; i++) {
3827 irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
3828 ioa_cfg->iopoll_weight, ipr_iopoll);
3831 spin_unlock_irqrestore(shost->host_lock, lock_flags);
3836 static struct device_attribute ipr_iopoll_weight_attr = {
3838 .name = "iopoll_weight",
3839 .mode = S_IRUGO | S_IWUSR,
3841 .show = ipr_show_iopoll_weight,
3842 .store = ipr_store_iopoll_weight
3846 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3847 * @buf_len: buffer length
3849 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3850 * list to use for microcode download
3853 * pointer to sglist / NULL on failure
3855 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3858 struct ipr_sglist *sglist;
3860 /* Get the minimum size per scatter/gather element */
3861 sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3863 /* Get the actual size per element */
3864 order = get_order(sg_size);
3866 /* Allocate a scatter/gather list for the DMA */
3867 sglist = kzalloc(sizeof(struct ipr_sglist), GFP_KERNEL);
3868 if (sglist == NULL) {
3872 sglist->order = order;
3873 sglist->scatterlist = sgl_alloc_order(buf_len, order, false, GFP_KERNEL,
3875 if (!sglist->scatterlist) {
3884 * ipr_free_ucode_buffer - Frees a microcode download buffer
3885 * @sglist: scatter/gather list pointer
3887 * Free a DMA'able ucode download buffer previously allocated with
3888 * ipr_alloc_ucode_buffer
3893 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3895 sgl_free_order(sglist->scatterlist, sglist->order);
3900 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3901 * @sglist: scatter/gather list pointer
3902 * @buffer: buffer pointer
3903 * @len: buffer length
3905 * Copy a microcode image from a user buffer into a buffer allocated by
3906 * ipr_alloc_ucode_buffer
3909 * 0 on success / other on failure
3911 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3912 u8 *buffer, u32 len)
3914 int bsize_elem, i, result = 0;
3915 struct scatterlist *sg;
3917 /* Determine the actual number of bytes per element */
3918 bsize_elem = PAGE_SIZE * (1 << sglist->order);
3920 sg = sglist->scatterlist;
3922 for (i = 0; i < (len / bsize_elem); i++, sg = sg_next(sg),
3923 buffer += bsize_elem) {
3924 struct page *page = sg_page(sg);
3926 memcpy_to_page(page, 0, buffer, bsize_elem);
3928 sg->length = bsize_elem;
3936 if (len % bsize_elem) {
3937 struct page *page = sg_page(sg);
3939 memcpy_to_page(page, 0, buffer, len % bsize_elem);
3941 sg->length = len % bsize_elem;
3944 sglist->buffer_len = len;
3949 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3950 * @ipr_cmd: ipr command struct
3951 * @sglist: scatter/gather list
3953 * Builds a microcode download IOA data list (IOADL).
3956 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3957 struct ipr_sglist *sglist)
3959 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3960 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3961 struct scatterlist *scatterlist = sglist->scatterlist;
3962 struct scatterlist *sg;
3965 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3966 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3967 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3970 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3971 for_each_sg(scatterlist, sg, ipr_cmd->dma_use_sg, i) {
3972 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3973 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
3974 ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
3977 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3981 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3982 * @ipr_cmd: ipr command struct
3983 * @sglist: scatter/gather list
3985 * Builds a microcode download IOA data list (IOADL).
3988 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3989 struct ipr_sglist *sglist)
3991 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3992 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3993 struct scatterlist *scatterlist = sglist->scatterlist;
3994 struct scatterlist *sg;
3997 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3998 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3999 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
4002 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
4004 for_each_sg(scatterlist, sg, ipr_cmd->dma_use_sg, i) {
4005 ioadl[i].flags_and_data_len =
4006 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(sg));
4008 cpu_to_be32(sg_dma_address(sg));
4011 ioadl[i-1].flags_and_data_len |=
4012 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
4016 * ipr_update_ioa_ucode - Update IOA's microcode
4017 * @ioa_cfg: ioa config struct
4018 * @sglist: scatter/gather list
4020 * Initiate an adapter reset to update the IOA's microcode
4023 * 0 on success / -EIO on failure
4025 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
4026 struct ipr_sglist *sglist)
4028 unsigned long lock_flags;
4030 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4031 while (ioa_cfg->in_reset_reload) {
4032 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4033 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4034 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4037 if (ioa_cfg->ucode_sglist) {
4038 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4039 dev_err(&ioa_cfg->pdev->dev,
4040 "Microcode download already in progress\n");
4044 sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
4045 sglist->scatterlist, sglist->num_sg,
4048 if (!sglist->num_dma_sg) {
4049 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4050 dev_err(&ioa_cfg->pdev->dev,
4051 "Failed to map microcode download buffer!\n");
4055 ioa_cfg->ucode_sglist = sglist;
4056 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
4057 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4058 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4060 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4061 ioa_cfg->ucode_sglist = NULL;
4062 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4067 * ipr_store_update_fw - Update the firmware on the adapter
4068 * @dev: device struct
4069 * @attr: device attribute (unused)
4071 * @count: buffer size
4073 * This function will update the firmware on the adapter.
4076 * count on success / other on failure
4078 static ssize_t ipr_store_update_fw(struct device *dev,
4079 struct device_attribute *attr,
4080 const char *buf, size_t count)
4082 struct Scsi_Host *shost = class_to_shost(dev);
4083 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4084 struct ipr_ucode_image_header *image_hdr;
4085 const struct firmware *fw_entry;
4086 struct ipr_sglist *sglist;
4090 int result, dnld_size;
4092 if (!capable(CAP_SYS_ADMIN))
4095 snprintf(fname, sizeof(fname), "%s", buf);
4097 endline = strchr(fname, '\n');
4101 if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
4102 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
4106 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
4108 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
4109 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
4110 sglist = ipr_alloc_ucode_buffer(dnld_size);
4113 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
4114 release_firmware(fw_entry);
4118 result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
4121 dev_err(&ioa_cfg->pdev->dev,
4122 "Microcode buffer copy to DMA buffer failed\n");
4126 ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n");
4128 result = ipr_update_ioa_ucode(ioa_cfg, sglist);
4133 ipr_free_ucode_buffer(sglist);
4134 release_firmware(fw_entry);
4138 static struct device_attribute ipr_update_fw_attr = {
4140 .name = "update_fw",
4143 .store = ipr_store_update_fw
4147 * ipr_show_fw_type - Show the adapter's firmware type.
4148 * @dev: class device struct
4149 * @attr: device attribute (unused)
4153 * number of bytes printed to buffer
4155 static ssize_t ipr_show_fw_type(struct device *dev,
4156 struct device_attribute *attr, char *buf)
4158 struct Scsi_Host *shost = class_to_shost(dev);
4159 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4160 unsigned long lock_flags = 0;
4163 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4164 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
4165 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4169 static struct device_attribute ipr_ioa_fw_type_attr = {
4174 .show = ipr_show_fw_type
4177 static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj,
4178 struct bin_attribute *bin_attr, char *buf,
4179 loff_t off, size_t count)
4181 struct device *cdev = kobj_to_dev(kobj);
4182 struct Scsi_Host *shost = class_to_shost(cdev);
4183 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4184 struct ipr_hostrcb *hostrcb;
4185 unsigned long lock_flags = 0;
4188 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4189 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4190 struct ipr_hostrcb, queue);
4192 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4195 ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam,
4196 sizeof(hostrcb->hcam));
4197 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4201 static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj,
4202 struct bin_attribute *bin_attr, char *buf,
4203 loff_t off, size_t count)
4205 struct device *cdev = kobj_to_dev(kobj);
4206 struct Scsi_Host *shost = class_to_shost(cdev);
4207 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4208 struct ipr_hostrcb *hostrcb;
4209 unsigned long lock_flags = 0;
4211 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4212 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4213 struct ipr_hostrcb, queue);
4215 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4219 /* Reclaim hostrcb before exit */
4220 list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
4221 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4225 static struct bin_attribute ipr_ioa_async_err_log = {
4227 .name = "async_err_log",
4228 .mode = S_IRUGO | S_IWUSR,
4231 .read = ipr_read_async_err_log,
4232 .write = ipr_next_async_err_log
4235 static struct attribute *ipr_ioa_attrs[] = {
4236 &ipr_fw_version_attr.attr,
4237 &ipr_log_level_attr.attr,
4238 &ipr_diagnostics_attr.attr,
4239 &ipr_ioa_state_attr.attr,
4240 &ipr_ioa_reset_attr.attr,
4241 &ipr_update_fw_attr.attr,
4242 &ipr_ioa_fw_type_attr.attr,
4243 &ipr_iopoll_weight_attr.attr,
4247 ATTRIBUTE_GROUPS(ipr_ioa);
4249 #ifdef CONFIG_SCSI_IPR_DUMP
4251 * ipr_read_dump - Dump the adapter
4252 * @filp: open sysfs file
4253 * @kobj: kobject struct
4254 * @bin_attr: bin_attribute struct
4257 * @count: buffer size
4260 * number of bytes printed to buffer
4262 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
4263 struct bin_attribute *bin_attr,
4264 char *buf, loff_t off, size_t count)
4266 struct device *cdev = kobj_to_dev(kobj);
4267 struct Scsi_Host *shost = class_to_shost(cdev);
4268 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4269 struct ipr_dump *dump;
4270 unsigned long lock_flags = 0;
4275 if (!capable(CAP_SYS_ADMIN))
4278 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4279 dump = ioa_cfg->dump;
4281 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
4282 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4285 kref_get(&dump->kref);
4286 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4288 if (off > dump->driver_dump.hdr.len) {
4289 kref_put(&dump->kref, ipr_release_dump);
4293 if (off + count > dump->driver_dump.hdr.len) {
4294 count = dump->driver_dump.hdr.len - off;
4298 if (count && off < sizeof(dump->driver_dump)) {
4299 if (off + count > sizeof(dump->driver_dump))
4300 len = sizeof(dump->driver_dump) - off;
4303 src = (u8 *)&dump->driver_dump + off;
4304 memcpy(buf, src, len);
4310 off -= sizeof(dump->driver_dump);
4313 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4314 (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
4315 sizeof(struct ipr_sdt_entry));
4317 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4318 (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
4320 if (count && off < sdt_end) {
4321 if (off + count > sdt_end)
4322 len = sdt_end - off;
4325 src = (u8 *)&dump->ioa_dump + off;
4326 memcpy(buf, src, len);
4335 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
4336 len = PAGE_ALIGN(off) - off;
4339 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
4340 src += off & ~PAGE_MASK;
4341 memcpy(buf, src, len);
4347 kref_put(&dump->kref, ipr_release_dump);
4352 * ipr_alloc_dump - Prepare for adapter dump
4353 * @ioa_cfg: ioa config struct
4356 * 0 on success / other on failure
4358 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
4360 struct ipr_dump *dump;
4362 unsigned long lock_flags = 0;
4364 dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
4367 ipr_err("Dump memory allocation failed\n");
4372 ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES,
4375 ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES,
4379 ipr_err("Dump memory allocation failed\n");
4384 dump->ioa_dump.ioa_data = ioa_data;
4386 kref_init(&dump->kref);
4387 dump->ioa_cfg = ioa_cfg;
4389 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4391 if (INACTIVE != ioa_cfg->sdt_state) {
4392 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4393 vfree(dump->ioa_dump.ioa_data);
4398 ioa_cfg->dump = dump;
4399 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
4400 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
4401 ioa_cfg->dump_taken = 1;
4402 schedule_work(&ioa_cfg->work_q);
4404 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4410 * ipr_free_dump - Free adapter dump memory
4411 * @ioa_cfg: ioa config struct
4414 * 0 on success / other on failure
4416 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4418 struct ipr_dump *dump;
4419 unsigned long lock_flags = 0;
4423 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4424 dump = ioa_cfg->dump;
4426 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4430 ioa_cfg->dump = NULL;
4431 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4433 kref_put(&dump->kref, ipr_release_dump);
4440 * ipr_write_dump - Setup dump state of adapter
4441 * @filp: open sysfs file
4442 * @kobj: kobject struct
4443 * @bin_attr: bin_attribute struct
4446 * @count: buffer size
4449 * number of bytes printed to buffer
4451 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4452 struct bin_attribute *bin_attr,
4453 char *buf, loff_t off, size_t count)
4455 struct device *cdev = kobj_to_dev(kobj);
4456 struct Scsi_Host *shost = class_to_shost(cdev);
4457 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4460 if (!capable(CAP_SYS_ADMIN))
4464 rc = ipr_alloc_dump(ioa_cfg);
4465 else if (buf[0] == '0')
4466 rc = ipr_free_dump(ioa_cfg);
4476 static struct bin_attribute ipr_dump_attr = {
4479 .mode = S_IRUSR | S_IWUSR,
4482 .read = ipr_read_dump,
4483 .write = ipr_write_dump
4486 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4490 * ipr_change_queue_depth - Change the device's queue depth
4491 * @sdev: scsi device struct
4492 * @qdepth: depth to set
4497 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
4499 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4500 struct ipr_resource_entry *res;
4501 unsigned long lock_flags = 0;
4503 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4504 res = (struct ipr_resource_entry *)sdev->hostdata;
4506 if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4507 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4508 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4510 scsi_change_queue_depth(sdev, qdepth);
4511 return sdev->queue_depth;
4515 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4516 * @dev: device struct
4517 * @attr: device attribute structure
4521 * number of bytes printed to buffer
4523 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4525 struct scsi_device *sdev = to_scsi_device(dev);
4526 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4527 struct ipr_resource_entry *res;
4528 unsigned long lock_flags = 0;
4529 ssize_t len = -ENXIO;
4531 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4532 res = (struct ipr_resource_entry *)sdev->hostdata;
4534 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4535 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4539 static struct device_attribute ipr_adapter_handle_attr = {
4541 .name = "adapter_handle",
4544 .show = ipr_show_adapter_handle
4548 * ipr_show_resource_path - Show the resource path or the resource address for
4550 * @dev: device struct
4551 * @attr: device attribute structure
4555 * number of bytes printed to buffer
4557 static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4559 struct scsi_device *sdev = to_scsi_device(dev);
4560 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4561 struct ipr_resource_entry *res;
4562 unsigned long lock_flags = 0;
4563 ssize_t len = -ENXIO;
4564 char buffer[IPR_MAX_RES_PATH_LENGTH];
4566 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4567 res = (struct ipr_resource_entry *)sdev->hostdata;
4568 if (res && ioa_cfg->sis64)
4569 len = snprintf(buf, PAGE_SIZE, "%s\n",
4570 __ipr_format_res_path(res->res_path, buffer,
4573 len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4574 res->bus, res->target, res->lun);
4576 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4580 static struct device_attribute ipr_resource_path_attr = {
4582 .name = "resource_path",
4585 .show = ipr_show_resource_path
4589 * ipr_show_device_id - Show the device_id for this device.
4590 * @dev: device struct
4591 * @attr: device attribute structure
4595 * number of bytes printed to buffer
4597 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4599 struct scsi_device *sdev = to_scsi_device(dev);
4600 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4601 struct ipr_resource_entry *res;
4602 unsigned long lock_flags = 0;
4603 ssize_t len = -ENXIO;
4605 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4606 res = (struct ipr_resource_entry *)sdev->hostdata;
4607 if (res && ioa_cfg->sis64)
4608 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id));
4610 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4612 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4616 static struct device_attribute ipr_device_id_attr = {
4618 .name = "device_id",
4621 .show = ipr_show_device_id
4625 * ipr_show_resource_type - Show the resource type for this device.
4626 * @dev: device struct
4627 * @attr: device attribute structure
4631 * number of bytes printed to buffer
4633 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4635 struct scsi_device *sdev = to_scsi_device(dev);
4636 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4637 struct ipr_resource_entry *res;
4638 unsigned long lock_flags = 0;
4639 ssize_t len = -ENXIO;
4641 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4642 res = (struct ipr_resource_entry *)sdev->hostdata;
4645 len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4647 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4651 static struct device_attribute ipr_resource_type_attr = {
4653 .name = "resource_type",
4656 .show = ipr_show_resource_type
4660 * ipr_show_raw_mode - Show the adapter's raw mode
4661 * @dev: class device struct
4662 * @attr: device attribute (unused)
4666 * number of bytes printed to buffer
4668 static ssize_t ipr_show_raw_mode(struct device *dev,
4669 struct device_attribute *attr, char *buf)
4671 struct scsi_device *sdev = to_scsi_device(dev);
4672 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4673 struct ipr_resource_entry *res;
4674 unsigned long lock_flags = 0;
4677 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4678 res = (struct ipr_resource_entry *)sdev->hostdata;
4680 len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode);
4683 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4688 * ipr_store_raw_mode - Change the adapter's raw mode
4689 * @dev: class device struct
4690 * @attr: device attribute (unused)
4692 * @count: buffer size
4695 * number of bytes printed to buffer
4697 static ssize_t ipr_store_raw_mode(struct device *dev,
4698 struct device_attribute *attr,
4699 const char *buf, size_t count)
4701 struct scsi_device *sdev = to_scsi_device(dev);
4702 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4703 struct ipr_resource_entry *res;
4704 unsigned long lock_flags = 0;
4707 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4708 res = (struct ipr_resource_entry *)sdev->hostdata;
4710 if (ipr_is_af_dasd_device(res)) {
4711 res->raw_mode = simple_strtoul(buf, NULL, 10);
4714 sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n",
4715 res->raw_mode ? "enabled" : "disabled");
4720 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4724 static struct device_attribute ipr_raw_mode_attr = {
4727 .mode = S_IRUGO | S_IWUSR,
4729 .show = ipr_show_raw_mode,
4730 .store = ipr_store_raw_mode
4733 static struct attribute *ipr_dev_attrs[] = {
4734 &ipr_adapter_handle_attr.attr,
4735 &ipr_resource_path_attr.attr,
4736 &ipr_device_id_attr.attr,
4737 &ipr_resource_type_attr.attr,
4738 &ipr_raw_mode_attr.attr,
4742 ATTRIBUTE_GROUPS(ipr_dev);
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.
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.
4758 static int ipr_biosparam(struct scsi_device *sdev,
4759 struct block_device *block_device,
4760 sector_t capacity, int *parm)
4768 cylinders = capacity;
4769 sector_div(cylinders, (128 * 32));
4774 parm[2] = cylinders;
4780 * ipr_find_starget - Find target based on bus/target.
4781 * @starget: scsi target struct
4784 * resource entry pointer if found / NULL if not found
4786 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
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;
4792 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4793 if ((res->bus == starget->channel) &&
4794 (res->target == starget->id)) {
4802 static struct ata_port_info sata_port_info;
4805 * ipr_target_alloc - Prepare for commands to a SCSI target
4806 * @starget: scsi target struct
4808 * If the device is a SATA device, this function allocates an
4809 * ATA port with libata, else it does nothing.
4812 * 0 on success / non-0 on failure
4814 static int ipr_target_alloc(struct scsi_target *starget)
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;
4823 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4824 res = ipr_find_starget(starget);
4825 starget->hostdata = NULL;
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);
4833 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4835 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4836 sata_port->ioa_cfg = ioa_cfg;
4838 sata_port->res = res;
4840 res->sata_port = sata_port;
4841 ap->private_data = sata_port;
4842 starget->hostdata = sata_port;
4848 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4854 * ipr_target_destroy - Destroy a SCSI target
4855 * @starget: scsi target struct
4857 * If the device was a SATA device, this function frees the libata
4858 * ATA port, else it does nothing.
4861 static void ipr_target_destroy(struct scsi_target *starget)
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;
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);
4879 starget->hostdata = NULL;
4880 ata_sas_port_destroy(sata_port->ap);
4886 * ipr_find_sdev - Find device based on bus/target/lun.
4887 * @sdev: scsi device struct
4890 * resource entry pointer if found / NULL if not found
4892 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4894 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4895 struct ipr_resource_entry *res;
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))
4908 * ipr_slave_destroy - Unconfigure a SCSI device
4909 * @sdev: scsi device struct
4914 static void ipr_slave_destroy(struct scsi_device *sdev)
4916 struct ipr_resource_entry *res;
4917 struct ipr_ioa_cfg *ioa_cfg;
4918 unsigned long lock_flags = 0;
4920 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4922 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4923 res = (struct ipr_resource_entry *) sdev->hostdata;
4926 res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4927 sdev->hostdata = NULL;
4929 res->sata_port = NULL;
4931 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4935 * ipr_slave_configure - Configure a SCSI device
4936 * @sdev: scsi device struct
4938 * This function configures the specified scsi device.
4943 static int ipr_slave_configure(struct scsi_device *sdev)
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];
4951 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4952 res = sdev->hostdata;
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;
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);
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);
4972 scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
4973 ata_sas_slave_configure(sdev, ap);
4977 sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4978 ipr_format_res_path(ioa_cfg,
4979 res->res_path, buffer, sizeof(buffer)));
4982 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4987 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4988 * @sdev: scsi device struct
4990 * This function initializes an ATA port so that future commands
4991 * sent through queuecommand will work.
4996 static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4998 struct ipr_sata_port *sata_port = NULL;
5002 if (sdev->sdev_target)
5003 sata_port = sdev->sdev_target->hostdata;
5005 rc = ata_sas_port_init(sata_port->ap);
5007 rc = ata_sas_sync_probe(sata_port->ap);
5011 ipr_slave_destroy(sdev);
5018 * ipr_slave_alloc - Prepare for commands to a device.
5019 * @sdev: scsi device struct
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.
5027 * 0 on success / -ENXIO if device does not exist
5029 static int ipr_slave_alloc(struct scsi_device *sdev)
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;
5036 sdev->hostdata = NULL;
5038 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5040 res = ipr_find_sdev(sdev);
5045 sdev->hostdata = res;
5046 if (!ipr_is_naca_model(res))
5047 res->needs_sync_complete = 1;
5049 if (ipr_is_gata(res)) {
5050 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5051 return ipr_ata_slave_alloc(sdev);
5055 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5061 * ipr_match_lun - Match function for specified LUN
5062 * @ipr_cmd: ipr command struct
5063 * @device: device to match (sdev)
5066 * 1 if command matches sdev / 0 if command does not match sdev
5068 static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device)
5070 if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device)
5076 * ipr_cmnd_is_free - Check if a command is free or not
5077 * @ipr_cmd: ipr command struct
5082 static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd)
5084 struct ipr_cmnd *loop_cmd;
5086 list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) {
5087 if (loop_cmd == ipr_cmd)
5095 * ipr_match_res - Match function for specified resource entry
5096 * @ipr_cmd: ipr command struct
5097 * @resource: resource entry to match
5100 * 1 if command matches sdev / 0 if command does not match sdev
5102 static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource)
5104 struct ipr_resource_entry *res = resource;
5106 if (res && ipr_cmd->ioarcb.res_handle == res->res_handle)
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
5120 static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device,
5121 int (*match)(struct ipr_cmnd *, void *))
5123 struct ipr_cmnd *ipr_cmd;
5125 unsigned long flags;
5126 struct ipr_hrr_queue *hrrq;
5127 signed long timeout = IPR_ABORT_TASK_TIMEOUT;
5128 DECLARE_COMPLETION_ONSTACK(comp);
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 = ∁
5145 spin_unlock_irqrestore(hrrq->lock, flags);
5149 timeout = wait_for_completion_timeout(&comp, timeout);
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;
5165 spin_unlock_irqrestore(hrrq->lock, flags);
5169 dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n");
5171 return wait ? FAILED : SUCCESS;
5180 static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
5182 struct ipr_ioa_cfg *ioa_cfg;
5183 unsigned long lock_flags = 0;
5187 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5188 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
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");
5195 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5196 ioa_cfg->sdt_state = GET_DUMP;
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);
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) {
5210 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5216 * ipr_device_reset - Reset the device
5217 * @ioa_cfg: ioa config struct
5218 * @res: resource entry struct
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
5227 * 0 on success / non-zero on failure
5229 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
5230 struct ipr_resource_entry *res)
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;
5239 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5240 ioarcb = &ipr_cmd->ioarcb;
5241 cmd_pkt = &ioarcb->cmd_pkt;
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));
5247 regs = &ioarcb->u.add_data.u.regs;
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;
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));
5266 memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
5267 sizeof(struct ipr_ioasa_gata));
5271 return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
5275 * ipr_sata_reset - Reset the SATA port
5276 * @link: SATA link to reset
5277 * @classes: class of the attached device
5280 * This function issues a SATA phy reset to the affected ATA link.
5283 * 0 on success / non-zero on failure
5285 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
5286 unsigned long deadline)
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;
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);
5302 res = sata_port->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);
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);
5314 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5317 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5324 * __ipr_eh_dev_reset - Reset the device
5325 * @scsi_cmd: scsi command struct
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.
5334 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
5336 struct ipr_cmnd *ipr_cmd;
5337 struct ipr_ioa_cfg *ioa_cfg;
5338 struct ipr_resource_entry *res;
5339 struct ata_port *ap;
5341 struct ipr_hrr_queue *hrrq;
5344 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5345 res = scsi_cmd->device->hostdata;
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
5352 if (ioa_cfg->in_reset_reload)
5354 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
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];
5362 if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
5365 if (ipr_cmnd_is_free(ipr_cmd))
5368 ipr_cmd->done = ipr_sata_eh_done;
5369 if (!(ipr_cmd->qc->flags & ATA_QCFLAG_EH)) {
5370 ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
5371 ipr_cmd->qc->flags |= ATA_QCFLAG_EH;
5375 spin_unlock(&hrrq->_lock);
5377 res->resetting_device = 1;
5378 scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
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);
5386 rc = ipr_device_reset(ioa_cfg, res);
5387 res->resetting_device = 0;
5388 res->reset_occurred = 1;
5391 return rc ? FAILED : SUCCESS;
5394 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
5397 struct ipr_ioa_cfg *ioa_cfg;
5398 struct ipr_resource_entry *res;
5400 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5401 res = cmd->device->hostdata;
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);
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);
5414 rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun);
5421 * ipr_bus_reset_done - Op done function for bus reset.
5422 * @ipr_cmd: ipr command struct
5424 * This function is the op done function for a bus reset
5429 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
5431 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5432 struct ipr_resource_entry *res;
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);
5444 * If abort has not completed, indicate the reset has, else call the
5445 * abort's done function to wake the sleeping eh thread
5447 if (ipr_cmd->sibling->sibling)
5448 ipr_cmd->sibling->sibling = NULL;
5450 ipr_cmd->sibling->done(ipr_cmd->sibling);
5452 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5457 * ipr_abort_timeout - An abort task has timed out
5458 * @t: Timer context used to fetch ipr command struct
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.
5467 static void ipr_abort_timeout(struct timer_list *t)
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;
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);
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;
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);
5498 * ipr_cancel_op - Cancel specified op
5499 * @scsi_cmd: scsi command struct
5501 * This function cancels specified op.
5506 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
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;
5513 int i, op_found = 0;
5514 struct ipr_hrr_queue *hrrq;
5517 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5518 res = scsi_cmd->device->hostdata;
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
5524 if (ioa_cfg->in_reset_reload ||
5525 ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
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.
5535 readl(ioa_cfg->regs.sense_interrupt_reg);
5537 if (!ipr_is_gscsi(res))
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])) {
5550 spin_unlock(&hrrq->_lock);
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;
5563 scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
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);
5569 * If the abort task timed out and we sent a bus reset, we will get
5570 * one the following responses to the abort
5572 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
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;
5582 return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
5586 * ipr_scan_finished - Report whether scan is done
5587 * @shost: scsi host struct
5588 * @elapsed_time: elapsed time
5591 * 0 if scan in progress / 1 if scan is complete
5593 static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time)
5595 unsigned long lock_flags;
5596 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
5599 spin_lock_irqsave(shost->host_lock, lock_flags);
5600 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done)
5602 if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2))
5604 spin_unlock_irqrestore(shost->host_lock, lock_flags);
5609 * ipr_eh_abort - Reset the host adapter
5610 * @scsi_cmd: scsi command struct
5615 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
5617 unsigned long flags;
5619 struct ipr_ioa_cfg *ioa_cfg;
5623 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
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);
5630 rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun);
5636 * ipr_handle_other_interrupt - Handle "other" interrupts
5637 * @ioa_cfg: ioa config struct
5638 * @int_reg: interrupt register
5641 * IRQ_NONE / IRQ_HANDLED
5643 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5646 irqreturn_t rc = IRQ_HANDLED;
5649 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5650 int_reg &= ~int_mask_reg;
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.
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) {
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);
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);
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);
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);
5698 dev_err(&ioa_cfg->pdev->dev,
5699 "Permanent IOA failure. 0x%08X\n", int_reg);
5701 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5702 ioa_cfg->sdt_state = GET_DUMP;
5704 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5705 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
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
5720 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number)
5722 ioa_cfg->errors_logged++;
5723 dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number);
5725 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5726 ioa_cfg->sdt_state = GET_DUMP;
5728 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5731 static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget,
5732 struct list_head *doneq)
5736 struct ipr_cmnd *ipr_cmd;
5737 struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg;
5740 /* If interrupts are disabled, ignore the interrupt */
5741 if (!hrr_queue->allow_interrupts)
5744 while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5745 hrr_queue->toggle_bit) {
5747 cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) &
5748 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >>
5749 IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
5751 if (unlikely(cmd_index > hrr_queue->max_cmd_id ||
5752 cmd_index < hrr_queue->min_cmd_id)) {
5754 "Invalid response handle from IOA: ",
5759 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
5760 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5762 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
5764 list_move_tail(&ipr_cmd->queue, doneq);
5766 if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) {
5767 hrr_queue->hrrq_curr++;
5769 hrr_queue->hrrq_curr = hrr_queue->hrrq_start;
5770 hrr_queue->toggle_bit ^= 1u;
5773 if (budget > 0 && num_hrrq >= budget)
5780 static int ipr_iopoll(struct irq_poll *iop, int budget)
5782 struct ipr_hrr_queue *hrrq;
5783 struct ipr_cmnd *ipr_cmd, *temp;
5784 unsigned long hrrq_flags;
5788 hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
5790 spin_lock_irqsave(hrrq->lock, hrrq_flags);
5791 completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
5793 if (completed_ops < budget)
5794 irq_poll_complete(iop);
5795 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
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);
5803 return completed_ops;
5807 * ipr_isr - Interrupt service routine
5809 * @devp: pointer to ioa config struct
5812 * IRQ_NONE / IRQ_HANDLED
5814 static irqreturn_t ipr_isr(int irq, void *devp)
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;
5822 struct ipr_cmnd *ipr_cmd, *temp;
5823 irqreturn_t rc = IRQ_NONE;
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);
5834 if (ipr_process_hrrq(hrrq, -1, &doneq)) {
5837 if (!ioa_cfg->clear_isr)
5840 /* Clear the PCI interrupt */
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);
5849 } else if (rc == IRQ_NONE && irq_none == 0) {
5850 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5852 } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
5853 int_reg & IPR_PCII_HRRQ_UPDATED) {
5855 "Error clearing HRRQ: ", num_hrrq);
5862 if (unlikely(rc == IRQ_NONE))
5863 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
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);
5875 * ipr_isr_mhrrq - Interrupt service routine
5877 * @devp: pointer to ioa config struct
5880 * IRQ_NONE / IRQ_HANDLED
5882 static irqreturn_t ipr_isr_mhrrq(int irq, void *devp)
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;
5891 spin_lock_irqsave(hrrq->lock, hrrq_flags);
5893 /* If interrupts are disabled, ignore the interrupt */
5894 if (!hrrq->allow_interrupts) {
5895 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
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) ==
5902 irq_poll_sched(&hrrq->iopoll);
5903 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5907 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5910 if (ipr_process_hrrq(hrrq, -1, &doneq))
5914 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
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);
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
5930 * 0 on success / -1 on failure
5932 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
5933 struct ipr_cmnd *ipr_cmd)
5936 struct scatterlist *sg;
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;
5943 length = scsi_bufflen(scsi_cmd);
5947 nseg = scsi_dma_map(scsi_cmd);
5949 if (printk_ratelimit())
5950 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5954 ipr_cmd->dma_use_sg = nseg;
5956 ioarcb->data_transfer_length = cpu_to_be32(length);
5958 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
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;
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));
5972 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
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
5982 * 0 on success / -1 on failure
5984 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
5985 struct ipr_cmnd *ipr_cmd)
5988 struct scatterlist *sg;
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;
5995 length = scsi_bufflen(scsi_cmd);
5999 nseg = scsi_dma_map(scsi_cmd);
6001 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
6005 ipr_cmd->dma_use_sg = nseg;
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);
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);
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;
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));
6033 ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6038 * __ipr_erp_done - Process completion of ERP for a device
6039 * @ipr_cmd: ipr command struct
6041 * This function copies the sense buffer into the scsi_cmd
6042 * struct and pushes the scsi_done function.
6047 static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd)
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);
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);
6058 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
6059 SCSI_SENSE_BUFFERSIZE);
6063 if (!ipr_is_naca_model(res))
6064 res->needs_sync_complete = 1;
6067 scsi_dma_unmap(ipr_cmd->scsi_cmd);
6068 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);
6075 * ipr_erp_done - Process completion of ERP for a device
6076 * @ipr_cmd: ipr command struct
6078 * This function copies the sense buffer into the scsi_cmd
6079 * struct and pushes the scsi_done function.
6084 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6086 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6087 unsigned long hrrq_flags;
6089 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6090 __ipr_erp_done(ipr_cmd);
6091 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6095 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
6096 * @ipr_cmd: ipr command struct
6101 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
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;
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;
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));
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;
6126 * __ipr_erp_request_sense - Send request sense to a device
6127 * @ipr_cmd: ipr command struct
6129 * This function sends a request sense to a device as a result
6130 * of a check condition.
6135 static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6137 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6138 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6140 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6141 __ipr_erp_done(ipr_cmd);
6145 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
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);
6154 ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
6155 SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
6157 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
6158 IPR_REQUEST_SENSE_TIMEOUT * 2);
6162 * ipr_erp_request_sense - Send request sense to a device
6163 * @ipr_cmd: ipr command struct
6165 * This function sends a request sense to a device as a result
6166 * of a check condition.
6171 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6173 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6174 unsigned long hrrq_flags;
6176 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6177 __ipr_erp_request_sense(ipr_cmd);
6178 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6182 * ipr_erp_cancel_all - Send cancel all to a device
6183 * @ipr_cmd: ipr command struct
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.
6193 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
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;
6201 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6203 if (!scsi_cmd->device->simple_tags) {
6204 __ipr_erp_request_sense(ipr_cmd);
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;
6212 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
6213 IPR_CANCEL_ALL_TIMEOUT);
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
6222 * This function is invoked by the interrupt handler when ops
6223 * fail. It will log the IOASA if appropriate. Only called
6229 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
6230 struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
6234 u32 ioasc, fd_ioasc;
6235 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6236 __be32 *ioasa_data = (__be32 *)ioasa;
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;
6245 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
6248 if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
6249 error_index = ipr_get_error(fd_ioasc);
6251 error_index = ipr_get_error(ioasc);
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)
6258 if (!ipr_is_gscsi(res))
6261 if (ipr_error_table[error_index].log_ioasa == 0)
6265 ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
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);
6273 ipr_err("IOASA Dump:\n");
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]));
6285 * ipr_gen_sense - Generate SCSI sense data from an IOASA
6286 * @ipr_cmd: ipr command struct
6291 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
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);
6299 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
6301 if (ioasc >= IPR_FIRST_DRIVER_IOASC)
6304 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
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);
6316 sense_buf[9] = 0x0A;
6317 sense_buf[10] = 0x80;
6319 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
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;
6326 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
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;
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);
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 */
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;
6350 ((IPR_FIELD_POINTER_MASK &
6351 be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
6353 (IPR_FIELD_POINTER_MASK &
6354 be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
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);
6360 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
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;
6369 sense_buf[7] = 6; /* additional length */
6375 * ipr_get_autosense - Copy autosense data to sense buffer
6376 * @ipr_cmd: ipr command struct
6378 * This function copies the autosense buffer to the buffer
6379 * in the scsi_cmd, if there is autosense available.
6382 * 1 if autosense was available / 0 if not
6384 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
6386 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6387 struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
6389 if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
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));
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));
6404 * ipr_erp_start - Process an error response for a SCSI op
6405 * @ioa_cfg: ioa config struct
6406 * @ipr_cmd: ipr command struct
6408 * This function determines whether or not to initiate ERP
6409 * on the affected device.
6414 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
6415 struct ipr_cmnd *ipr_cmd)
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;
6423 __ipr_scsi_eh_done(ipr_cmd);
6427 if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
6428 ipr_gen_sense(ipr_cmd);
6430 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
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);
6437 scsi_cmd->result |= (DID_IMM_RETRY << 16);
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);
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;
6448 case IPR_IOASC_SYNC_REQUIRED:
6450 res->needs_sync_complete = 1;
6451 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6453 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
6454 case IPR_IOASA_IR_DUAL_IOA_DISABLED:
6456 * exception: do not set DID_PASSTHROUGH on CHECK CONDITION
6457 * so SCSI mid-layer and upper layers handle it accordingly.
6459 if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION)
6460 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
6462 case IPR_IOASC_BUS_WAS_RESET:
6463 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
6465 * Report the bus reset and ask for a retry. The device
6466 * will give CC/UA the next command.
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;
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);
6484 if (!ipr_is_naca_model(res))
6485 res->needs_sync_complete = 1;
6487 case IPR_IOASC_NR_INIT_CMD_REQUIRED:
6489 case IPR_IOASC_IR_NON_OPTIMIZED:
6490 if (res->raw_mode) {
6492 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6494 scsi_cmd->result |= (DID_ERROR << 16);
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;
6504 scsi_dma_unmap(ipr_cmd->scsi_cmd);
6505 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);
6512 * ipr_scsi_done - mid-layer done function
6513 * @ipr_cmd: ipr command struct
6515 * This function is invoked by the interrupt handler for
6516 * ops generated by the SCSI mid-layer
6521 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
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;
6528 scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
6530 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
6531 scsi_dma_unmap(scsi_cmd);
6533 spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags);
6534 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);
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);
6549 * ipr_queuecommand - Queue a mid-layer request
6550 * @shost: scsi host struct
6551 * @scsi_cmd: scsi command struct
6553 * This function queues a request generated by the mid-layer.
6557 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6558 * SCSI_MLQUEUE_HOST_BUSY if host is busy
6560 static int ipr_queuecommand(struct Scsi_Host *shost,
6561 struct scsi_cmnd *scsi_cmd)
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;
6569 struct ipr_hrr_queue *hrrq;
6572 ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
6574 scsi_cmd->result = (DID_OK << 16);
6575 res = scsi_cmd->device->hostdata;
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);
6584 hrrq_id = ipr_get_hrrq_index(ioa_cfg);
6585 hrrq = &ioa_cfg->hrrq[hrrq_id];
6587 spin_lock_irqsave(hrrq->lock, hrrq_flags);
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
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;
6599 * FIXME - Create scsi_set_host_offline interface
6600 * and the ioa_is_dead check can be removed
6602 if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) {
6603 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
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;
6612 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6614 ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done);
6615 ioarcb = &ipr_cmd->ioarcb;
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;
6621 if (ipr_is_gscsi(res)) {
6622 if (scsi_cmd->underflow == 0)
6623 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6625 if (res->reset_occurred) {
6626 res->reset_occurred = 0;
6627 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
6631 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
6632 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
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;
6638 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
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;
6645 if (res->raw_mode && ipr_is_af_dasd_device(res)) {
6646 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE;
6648 if (scsi_cmd->underflow == 0)
6649 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6653 rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
6655 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
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);
6662 scsi_dma_unmap(scsi_cmd);
6663 return SCSI_MLQUEUE_HOST_BUSY;
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);
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;
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);
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_done(scsi_cmd);
6689 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6694 * ipr_ioctl - IOCTL handler
6695 * @sdev: scsi device struct
6700 * 0 on success / other on failure
6702 static int ipr_ioctl(struct scsi_device *sdev, unsigned int cmd,
6705 struct ipr_resource_entry *res;
6707 res = (struct ipr_resource_entry *)sdev->hostdata;
6708 if (res && ipr_is_gata(res)) {
6709 if (cmd == HDIO_GET_IDENTITY)
6711 return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
6718 * ipr_ioa_info - Get information about the card/driver
6719 * @host: scsi host struct
6722 * pointer to buffer with description string
6724 static const char *ipr_ioa_info(struct Scsi_Host *host)
6726 static char buffer[512];
6727 struct ipr_ioa_cfg *ioa_cfg;
6728 unsigned long lock_flags = 0;
6730 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
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);
6739 static struct scsi_host_template driver_template = {
6740 .module = THIS_MODULE,
6742 .info = ipr_ioa_info,
6744 #ifdef CONFIG_COMPAT
6745 .compat_ioctl = ipr_ioctl,
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,
6762 .sg_tablesize = IPR_MAX_SGLIST,
6763 .max_sectors = IPR_IOA_MAX_SECTORS,
6764 .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
6765 .shost_groups = ipr_ioa_groups,
6766 .sdev_groups = ipr_dev_groups,
6767 .proc_name = IPR_NAME,
6771 * ipr_ata_phy_reset - libata phy_reset handler
6772 * @ap: ata port to reset
6775 static void ipr_ata_phy_reset(struct ata_port *ap)
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;
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);
6791 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds)
6794 rc = ipr_device_reset(ioa_cfg, res);
6797 ap->link.device[0].class = ATA_DEV_NONE;
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;
6806 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6811 * ipr_ata_post_internal - Cleanup after an internal command
6812 * @qc: ATA queued command
6817 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
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;
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);
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);
6840 spin_unlock(&hrrq->_lock);
6842 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6846 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6847 * @regs: destination
6848 * @tf: source ATA taskfile
6853 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
6854 struct ata_taskfile *tf)
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;
6872 * ipr_sata_done - done function for SATA commands
6873 * @ipr_cmd: ipr command struct
6875 * This function is invoked by the interrupt handler for
6876 * ops generated by the SCSI mid-layer to SATA devices
6881 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
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);
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));
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);
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);
6901 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6902 qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
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);
6911 * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6912 * @ipr_cmd: ipr command struct
6913 * @qc: ATA queued command
6916 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
6917 struct ata_queued_cmd *qc)
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;
6926 dma_addr_t dma_addr = ipr_cmd->dma_addr;
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;
6937 ioarcb->data_transfer_length = cpu_to_be32(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));
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));
6948 last_ioadl64 = ioadl64;
6952 if (likely(last_ioadl64))
6953 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6957 * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6958 * @ipr_cmd: ipr command struct
6959 * @qc: ATA queued command
6962 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
6963 struct ata_queued_cmd *qc)
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;
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);
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);
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));
6997 if (likely(last_ioadl))
6998 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
7002 * ipr_qc_defer - Get a free ipr_cmd
7003 * @qc: queued command
7008 static int ipr_qc_defer(struct ata_queued_cmd *qc)
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;
7017 hrrq_id = ipr_get_hrrq_index(ioa_cfg);
7018 hrrq = &ioa_cfg->hrrq[hrrq_id];
7020 qc->lldd_task = NULL;
7021 spin_lock(&hrrq->_lock);
7022 if (unlikely(hrrq->ioa_is_dead)) {
7023 spin_unlock(&hrrq->_lock);
7027 if (unlikely(!hrrq->allow_cmds)) {
7028 spin_unlock(&hrrq->_lock);
7029 return ATA_DEFER_LINK;
7032 ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
7033 if (ipr_cmd == NULL) {
7034 spin_unlock(&hrrq->_lock);
7035 return ATA_DEFER_LINK;
7038 qc->lldd_task = ipr_cmd;
7039 spin_unlock(&hrrq->_lock);
7044 * ipr_qc_issue - Issue a SATA qc to a device
7045 * @qc: queued command
7050 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
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;
7060 if (qc->lldd_task == NULL)
7063 ipr_cmd = qc->lldd_task;
7064 if (ipr_cmd == NULL)
7065 return AC_ERR_SYSTEM;
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;
7076 ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
7077 ioarcb = &ipr_cmd->ioarcb;
7079 if (ioa_cfg->sis64) {
7080 regs = &ipr_cmd->i.ata_ioadl.regs;
7081 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
7083 regs = &ioarcb->u.add_data.u.regs;
7085 memset(regs, 0, sizeof(*regs));
7086 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
7088 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
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;
7098 ipr_build_ata_ioadl64(ipr_cmd, qc);
7100 ipr_build_ata_ioadl(ipr_cmd, qc);
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));
7107 switch (qc->tf.protocol) {
7108 case ATA_PROT_NODATA:
7113 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7116 case ATAPI_PROT_PIO:
7117 case ATAPI_PROT_NODATA:
7118 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7121 case ATAPI_PROT_DMA:
7122 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7123 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7128 spin_unlock(&ipr_cmd->hrrq->_lock);
7129 return AC_ERR_INVALID;
7132 ipr_send_command(ipr_cmd);
7133 spin_unlock(&ipr_cmd->hrrq->_lock);
7139 * ipr_qc_fill_rtf - Read result TF
7140 * @qc: ATA queued command
7142 static void ipr_qc_fill_rtf(struct ata_queued_cmd *qc)
7144 struct ipr_sata_port *sata_port = qc->ap->private_data;
7145 struct ipr_ioasa_gata *g = &sata_port->ioasa;
7146 struct ata_taskfile *tf = &qc->result_tf;
7148 tf->feature = g->error;
7149 tf->nsect = g->nsect;
7153 tf->device = g->device;
7154 tf->command = g->status;
7155 tf->hob_nsect = g->hob_nsect;
7156 tf->hob_lbal = g->hob_lbal;
7157 tf->hob_lbam = g->hob_lbam;
7158 tf->hob_lbah = g->hob_lbah;
7161 static struct ata_port_operations ipr_sata_ops = {
7162 .phy_reset = ipr_ata_phy_reset,
7163 .hardreset = ipr_sata_reset,
7164 .post_internal_cmd = ipr_ata_post_internal,
7165 .qc_prep = ata_noop_qc_prep,
7166 .qc_defer = ipr_qc_defer,
7167 .qc_issue = ipr_qc_issue,
7168 .qc_fill_rtf = ipr_qc_fill_rtf,
7169 .port_start = ata_sas_port_start,
7170 .port_stop = ata_sas_port_stop
7173 static struct ata_port_info sata_port_info = {
7174 .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
7176 .pio_mask = ATA_PIO4_ONLY,
7177 .mwdma_mask = ATA_MWDMA2,
7178 .udma_mask = ATA_UDMA6,
7179 .port_ops = &ipr_sata_ops
7182 #ifdef CONFIG_PPC_PSERIES
7183 static const u16 ipr_blocked_processors[] = {
7195 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
7196 * @ioa_cfg: ioa cfg struct
7198 * Adapters that use Gemstone revision < 3.1 do not work reliably on
7199 * certain pSeries hardware. This function determines if the given
7200 * adapter is in one of these confgurations or not.
7203 * 1 if adapter is not supported / 0 if adapter is supported
7205 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
7209 if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
7210 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
7211 if (pvr_version_is(ipr_blocked_processors[i]))
7218 #define ipr_invalid_adapter(ioa_cfg) 0
7222 * ipr_ioa_bringdown_done - IOA bring down completion.
7223 * @ipr_cmd: ipr command struct
7225 * This function processes the completion of an adapter bring down.
7226 * It wakes any reset sleepers.
7231 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
7233 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7237 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
7239 ioa_cfg->scsi_unblock = 1;
7240 schedule_work(&ioa_cfg->work_q);
7243 ioa_cfg->in_reset_reload = 0;
7244 ioa_cfg->reset_retries = 0;
7245 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
7246 spin_lock(&ioa_cfg->hrrq[i]._lock);
7247 ioa_cfg->hrrq[i].ioa_is_dead = 1;
7248 spin_unlock(&ioa_cfg->hrrq[i]._lock);
7252 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7253 wake_up_all(&ioa_cfg->reset_wait_q);
7256 return IPR_RC_JOB_RETURN;
7260 * ipr_ioa_reset_done - IOA reset completion.
7261 * @ipr_cmd: ipr command struct
7263 * This function processes the completion of an adapter reset.
7264 * It schedules any necessary mid-layer add/removes and
7265 * wakes any reset sleepers.
7270 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
7272 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7273 struct ipr_resource_entry *res;
7277 ioa_cfg->in_reset_reload = 0;
7278 for (j = 0; j < ioa_cfg->hrrq_num; j++) {
7279 spin_lock(&ioa_cfg->hrrq[j]._lock);
7280 ioa_cfg->hrrq[j].allow_cmds = 1;
7281 spin_unlock(&ioa_cfg->hrrq[j]._lock);
7284 ioa_cfg->reset_cmd = NULL;
7285 ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
7287 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
7288 if (res->add_to_ml || res->del_from_ml) {
7293 schedule_work(&ioa_cfg->work_q);
7295 for (j = 0; j < IPR_NUM_HCAMS; j++) {
7296 list_del_init(&ioa_cfg->hostrcb[j]->queue);
7297 if (j < IPR_NUM_LOG_HCAMS)
7298 ipr_send_hcam(ioa_cfg,
7299 IPR_HCAM_CDB_OP_CODE_LOG_DATA,
7300 ioa_cfg->hostrcb[j]);
7302 ipr_send_hcam(ioa_cfg,
7303 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
7304 ioa_cfg->hostrcb[j]);
7307 scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
7308 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
7310 ioa_cfg->reset_retries = 0;
7311 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7312 wake_up_all(&ioa_cfg->reset_wait_q);
7314 ioa_cfg->scsi_unblock = 1;
7315 schedule_work(&ioa_cfg->work_q);
7317 return IPR_RC_JOB_RETURN;
7321 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7322 * @supported_dev: supported device struct
7323 * @vpids: vendor product id struct
7328 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
7329 struct ipr_std_inq_vpids *vpids)
7331 memset(supported_dev, 0, sizeof(struct ipr_supported_device));
7332 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
7333 supported_dev->num_records = 1;
7334 supported_dev->data_length =
7335 cpu_to_be16(sizeof(struct ipr_supported_device));
7336 supported_dev->reserved = 0;
7340 * ipr_set_supported_devs - Send Set Supported Devices for a device
7341 * @ipr_cmd: ipr command struct
7343 * This function sends a Set Supported Devices to the adapter
7346 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7348 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
7350 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7351 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
7352 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7353 struct ipr_resource_entry *res = ipr_cmd->u.res;
7355 ipr_cmd->job_step = ipr_ioa_reset_done;
7357 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
7358 if (!ipr_is_scsi_disk(res))
7361 ipr_cmd->u.res = res;
7362 ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
7364 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7365 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7366 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7368 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
7369 ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
7370 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
7371 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
7373 ipr_init_ioadl(ipr_cmd,
7374 ioa_cfg->vpd_cbs_dma +
7375 offsetof(struct ipr_misc_cbs, supp_dev),
7376 sizeof(struct ipr_supported_device),
7377 IPR_IOADL_FLAGS_WRITE_LAST);
7379 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7380 IPR_SET_SUP_DEVICE_TIMEOUT);
7382 if (!ioa_cfg->sis64)
7383 ipr_cmd->job_step = ipr_set_supported_devs;
7385 return IPR_RC_JOB_RETURN;
7389 return IPR_RC_JOB_CONTINUE;
7393 * ipr_get_mode_page - Locate specified mode page
7394 * @mode_pages: mode page buffer
7395 * @page_code: page code to find
7396 * @len: minimum required length for mode page
7399 * pointer to mode page / NULL on failure
7401 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
7402 u32 page_code, u32 len)
7404 struct ipr_mode_page_hdr *mode_hdr;
7408 if (!mode_pages || (mode_pages->hdr.length == 0))
7411 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
7412 mode_hdr = (struct ipr_mode_page_hdr *)
7413 (mode_pages->data + mode_pages->hdr.block_desc_len);
7416 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
7417 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
7421 page_length = (sizeof(struct ipr_mode_page_hdr) +
7422 mode_hdr->page_length);
7423 length -= page_length;
7424 mode_hdr = (struct ipr_mode_page_hdr *)
7425 ((unsigned long)mode_hdr + page_length);
7432 * ipr_check_term_power - Check for term power errors
7433 * @ioa_cfg: ioa config struct
7434 * @mode_pages: IOAFP mode pages buffer
7436 * Check the IOAFP's mode page 28 for term power errors
7441 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
7442 struct ipr_mode_pages *mode_pages)
7446 struct ipr_dev_bus_entry *bus;
7447 struct ipr_mode_page28 *mode_page;
7449 mode_page = ipr_get_mode_page(mode_pages, 0x28,
7450 sizeof(struct ipr_mode_page28));
7452 entry_length = mode_page->entry_length;
7454 bus = mode_page->bus;
7456 for (i = 0; i < mode_page->num_entries; i++) {
7457 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
7458 dev_err(&ioa_cfg->pdev->dev,
7459 "Term power is absent on scsi bus %d\n",
7463 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
7468 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7469 * @ioa_cfg: ioa config struct
7471 * Looks through the config table checking for SES devices. If
7472 * the SES device is in the SES table indicating a maximum SCSI
7473 * bus speed, the speed is limited for the bus.
7478 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
7483 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
7484 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
7485 ioa_cfg->bus_attr[i].bus_width);
7487 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
7488 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
7493 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7494 * @ioa_cfg: ioa config struct
7495 * @mode_pages: mode page 28 buffer
7497 * Updates mode page 28 based on driver configuration
7502 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
7503 struct ipr_mode_pages *mode_pages)
7505 int i, entry_length;
7506 struct ipr_dev_bus_entry *bus;
7507 struct ipr_bus_attributes *bus_attr;
7508 struct ipr_mode_page28 *mode_page;
7510 mode_page = ipr_get_mode_page(mode_pages, 0x28,
7511 sizeof(struct ipr_mode_page28));
7513 entry_length = mode_page->entry_length;
7515 /* Loop for each device bus entry */
7516 for (i = 0, bus = mode_page->bus;
7517 i < mode_page->num_entries;
7518 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
7519 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
7520 dev_err(&ioa_cfg->pdev->dev,
7521 "Invalid resource address reported: 0x%08X\n",
7522 IPR_GET_PHYS_LOC(bus->res_addr));
7526 bus_attr = &ioa_cfg->bus_attr[i];
7527 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
7528 bus->bus_width = bus_attr->bus_width;
7529 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
7530 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
7531 if (bus_attr->qas_enabled)
7532 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
7534 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
7539 * ipr_build_mode_select - Build a mode select command
7540 * @ipr_cmd: ipr command struct
7541 * @res_handle: resource handle to send command to
7542 * @parm: Byte 2 of Mode Sense command
7543 * @dma_addr: DMA buffer address
7544 * @xfer_len: data transfer length
7549 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
7550 __be32 res_handle, u8 parm,
7551 dma_addr_t dma_addr, u8 xfer_len)
7553 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7555 ioarcb->res_handle = res_handle;
7556 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7557 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7558 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
7559 ioarcb->cmd_pkt.cdb[1] = parm;
7560 ioarcb->cmd_pkt.cdb[4] = xfer_len;
7562 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
7566 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7567 * @ipr_cmd: ipr command struct
7569 * This function sets up the SCSI bus attributes and sends
7570 * a Mode Select for Page 28 to activate them.
7575 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
7577 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7578 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7582 ipr_scsi_bus_speed_limit(ioa_cfg);
7583 ipr_check_term_power(ioa_cfg, mode_pages);
7584 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
7585 length = mode_pages->hdr.length + 1;
7586 mode_pages->hdr.length = 0;
7588 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7589 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7592 ipr_cmd->job_step = ipr_set_supported_devs;
7593 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7594 struct ipr_resource_entry, queue);
7595 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7598 return IPR_RC_JOB_RETURN;
7602 * ipr_build_mode_sense - Builds a mode sense command
7603 * @ipr_cmd: ipr command struct
7604 * @res_handle: resource entry struct
7605 * @parm: Byte 2 of mode sense command
7606 * @dma_addr: DMA address of mode sense buffer
7607 * @xfer_len: Size of DMA buffer
7612 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
7614 u8 parm, dma_addr_t dma_addr, u8 xfer_len)
7616 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7618 ioarcb->res_handle = res_handle;
7619 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
7620 ioarcb->cmd_pkt.cdb[2] = parm;
7621 ioarcb->cmd_pkt.cdb[4] = xfer_len;
7622 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7624 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
7628 * ipr_reset_cmd_failed - Handle failure of IOA reset command
7629 * @ipr_cmd: ipr command struct
7631 * This function handles the failure of an IOA bringup command.
7636 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
7638 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7639 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7641 dev_err(&ioa_cfg->pdev->dev,
7642 "0x%02X failed with IOASC: 0x%08X\n",
7643 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
7645 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
7646 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7647 return IPR_RC_JOB_RETURN;
7651 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7652 * @ipr_cmd: ipr command struct
7654 * This function handles the failure of a Mode Sense to the IOAFP.
7655 * Some adapters do not handle all mode pages.
7658 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7660 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
7662 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7663 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7665 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7666 ipr_cmd->job_step = ipr_set_supported_devs;
7667 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7668 struct ipr_resource_entry, queue);
7669 return IPR_RC_JOB_CONTINUE;
7672 return ipr_reset_cmd_failed(ipr_cmd);
7676 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7677 * @ipr_cmd: ipr command struct
7679 * This function send a Page 28 mode sense to the IOA to
7680 * retrieve SCSI bus attributes.
7685 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
7687 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7690 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7691 0x28, ioa_cfg->vpd_cbs_dma +
7692 offsetof(struct ipr_misc_cbs, mode_pages),
7693 sizeof(struct ipr_mode_pages));
7695 ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
7696 ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
7698 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7701 return IPR_RC_JOB_RETURN;
7705 * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7706 * @ipr_cmd: ipr command struct
7708 * This function enables dual IOA RAID support if possible.
7713 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
7715 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7716 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7717 struct ipr_mode_page24 *mode_page;
7721 mode_page = ipr_get_mode_page(mode_pages, 0x24,
7722 sizeof(struct ipr_mode_page24));
7725 mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
7727 length = mode_pages->hdr.length + 1;
7728 mode_pages->hdr.length = 0;
7730 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7731 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7734 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7735 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7738 return IPR_RC_JOB_RETURN;
7742 * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7743 * @ipr_cmd: ipr command struct
7745 * This function handles the failure of a Mode Sense to the IOAFP.
7746 * Some adapters do not handle all mode pages.
7749 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7751 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
7753 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7755 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7756 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7757 return IPR_RC_JOB_CONTINUE;
7760 return ipr_reset_cmd_failed(ipr_cmd);
7764 * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7765 * @ipr_cmd: ipr command struct
7767 * This function send a mode sense to the IOA to retrieve
7768 * the IOA Advanced Function Control mode page.
7773 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
7775 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7778 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7779 0x24, ioa_cfg->vpd_cbs_dma +
7780 offsetof(struct ipr_misc_cbs, mode_pages),
7781 sizeof(struct ipr_mode_pages));
7783 ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
7784 ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
7786 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7789 return IPR_RC_JOB_RETURN;
7793 * ipr_init_res_table - Initialize the resource table
7794 * @ipr_cmd: ipr command struct
7796 * This function looks through the existing resource table, comparing
7797 * it with the config table. This function will take care of old/new
7798 * devices and schedule adding/removing them from the mid-layer
7802 * IPR_RC_JOB_CONTINUE
7804 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
7806 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7807 struct ipr_resource_entry *res, *temp;
7808 struct ipr_config_table_entry_wrapper cfgtew;
7809 int entries, found, flag, i;
7814 flag = ioa_cfg->u.cfg_table64->hdr64.flags;
7816 flag = ioa_cfg->u.cfg_table->hdr.flags;
7818 if (flag & IPR_UCODE_DOWNLOAD_REQ)
7819 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
7821 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
7822 list_move_tail(&res->queue, &old_res);
7825 entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
7827 entries = ioa_cfg->u.cfg_table->hdr.num_entries;
7829 for (i = 0; i < entries; i++) {
7831 cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
7833 cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
7836 list_for_each_entry_safe(res, temp, &old_res, queue) {
7837 if (ipr_is_same_device(res, &cfgtew)) {
7838 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7845 if (list_empty(&ioa_cfg->free_res_q)) {
7846 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
7851 res = list_entry(ioa_cfg->free_res_q.next,
7852 struct ipr_resource_entry, queue);
7853 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7854 ipr_init_res_entry(res, &cfgtew);
7856 } else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res)))
7857 res->sdev->allow_restart = 1;
7860 ipr_update_res_entry(res, &cfgtew);
7863 list_for_each_entry_safe(res, temp, &old_res, queue) {
7865 res->del_from_ml = 1;
7866 res->res_handle = IPR_INVALID_RES_HANDLE;
7867 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7871 list_for_each_entry_safe(res, temp, &old_res, queue) {
7872 ipr_clear_res_target(res);
7873 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
7876 if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
7877 ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
7879 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7882 return IPR_RC_JOB_CONTINUE;
7886 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7887 * @ipr_cmd: ipr command struct
7889 * This function sends a Query IOA Configuration command
7890 * to the adapter to retrieve the IOA configuration table.
7895 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
7897 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7898 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7899 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
7900 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
7903 if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
7904 ioa_cfg->dual_raid = 1;
7905 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
7906 ucode_vpd->major_release, ucode_vpd->card_type,
7907 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
7908 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7909 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7911 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
7912 ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
7913 ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
7914 ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
7916 ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
7917 IPR_IOADL_FLAGS_READ_LAST);
7919 ipr_cmd->job_step = ipr_init_res_table;
7921 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7924 return IPR_RC_JOB_RETURN;
7927 static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd)
7929 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7931 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT)
7932 return IPR_RC_JOB_CONTINUE;
7934 return ipr_reset_cmd_failed(ipr_cmd);
7937 static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd,
7938 __be32 res_handle, u8 sa_code)
7940 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7942 ioarcb->res_handle = res_handle;
7943 ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION;
7944 ioarcb->cmd_pkt.cdb[1] = sa_code;
7945 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7949 * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7951 * @ipr_cmd: ipr command struct
7956 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd)
7958 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7959 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7960 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
7964 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
7966 if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) {
7967 ipr_build_ioa_service_action(ipr_cmd,
7968 cpu_to_be32(IPR_IOA_RES_HANDLE),
7969 IPR_IOA_SA_CHANGE_CACHE_PARAMS);
7971 ioarcb->cmd_pkt.cdb[2] = 0x40;
7973 ipr_cmd->job_step_failed = ipr_ioa_service_action_failed;
7974 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7975 IPR_SET_SUP_DEVICE_TIMEOUT);
7978 return IPR_RC_JOB_RETURN;
7982 return IPR_RC_JOB_CONTINUE;
7986 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7987 * @ipr_cmd: ipr command struct
7988 * @flags: flags to send
7989 * @page: page to inquire
7990 * @dma_addr: DMA address
7991 * @xfer_len: transfer data length
7993 * This utility function sends an inquiry to the adapter.
7998 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
7999 dma_addr_t dma_addr, u8 xfer_len)
8001 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8004 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
8005 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8007 ioarcb->cmd_pkt.cdb[0] = INQUIRY;
8008 ioarcb->cmd_pkt.cdb[1] = flags;
8009 ioarcb->cmd_pkt.cdb[2] = page;
8010 ioarcb->cmd_pkt.cdb[4] = xfer_len;
8012 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
8014 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
8019 * ipr_inquiry_page_supported - Is the given inquiry page supported
8020 * @page0: inquiry page 0 buffer
8023 * This function determines if the specified inquiry page is supported.
8026 * 1 if page is supported / 0 if not
8028 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
8032 for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
8033 if (page0->page[i] == page)
8040 * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
8041 * @ipr_cmd: ipr command struct
8043 * This function sends a Page 0xC4 inquiry to the adapter
8044 * to retrieve software VPD information.
8047 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8049 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd)
8051 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8052 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8053 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
8056 ipr_cmd->job_step = ipr_ioafp_set_caching_parameters;
8057 memset(pageC4, 0, sizeof(*pageC4));
8059 if (ipr_inquiry_page_supported(page0, 0xC4)) {
8060 ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4,
8061 (ioa_cfg->vpd_cbs_dma
8062 + offsetof(struct ipr_misc_cbs,
8064 sizeof(struct ipr_inquiry_pageC4));
8065 return IPR_RC_JOB_RETURN;
8069 return IPR_RC_JOB_CONTINUE;
8073 * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
8074 * @ipr_cmd: ipr command struct
8076 * This function sends a Page 0xD0 inquiry to the adapter
8077 * to retrieve adapter capabilities.
8080 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8082 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
8084 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8085 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8086 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
8089 ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry;
8090 memset(cap, 0, sizeof(*cap));
8092 if (ipr_inquiry_page_supported(page0, 0xD0)) {
8093 ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
8094 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
8095 sizeof(struct ipr_inquiry_cap));
8096 return IPR_RC_JOB_RETURN;
8100 return IPR_RC_JOB_CONTINUE;
8104 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
8105 * @ipr_cmd: ipr command struct
8107 * This function sends a Page 3 inquiry to the adapter
8108 * to retrieve software VPD information.
8111 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8113 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
8115 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8119 ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
8121 ipr_ioafp_inquiry(ipr_cmd, 1, 3,
8122 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
8123 sizeof(struct ipr_inquiry_page3));
8126 return IPR_RC_JOB_RETURN;
8130 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
8131 * @ipr_cmd: ipr command struct
8133 * This function sends a Page 0 inquiry to the adapter
8134 * to retrieve supported inquiry pages.
8137 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8139 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
8141 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8146 /* Grab the type out of the VPD and store it away */
8147 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
8149 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
8151 if (ipr_invalid_adapter(ioa_cfg)) {
8152 dev_err(&ioa_cfg->pdev->dev,
8153 "Adapter not supported in this hardware configuration.\n");
8155 if (!ipr_testmode) {
8156 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
8157 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
8158 list_add_tail(&ipr_cmd->queue,
8159 &ioa_cfg->hrrq->hrrq_free_q);
8160 return IPR_RC_JOB_RETURN;
8164 ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
8166 ipr_ioafp_inquiry(ipr_cmd, 1, 0,
8167 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
8168 sizeof(struct ipr_inquiry_page0));
8171 return IPR_RC_JOB_RETURN;
8175 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
8176 * @ipr_cmd: ipr command struct
8178 * This function sends a standard inquiry to the adapter.
8183 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
8185 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8188 ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
8190 ipr_ioafp_inquiry(ipr_cmd, 0, 0,
8191 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
8192 sizeof(struct ipr_ioa_vpd));
8195 return IPR_RC_JOB_RETURN;
8199 * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
8200 * @ipr_cmd: ipr command struct
8202 * This function send an Identify Host Request Response Queue
8203 * command to establish the HRRQ with the adapter.
8208 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
8210 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8211 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8212 struct ipr_hrr_queue *hrrq;
8215 ipr_cmd->job_step = ipr_ioafp_std_inquiry;
8216 if (ioa_cfg->identify_hrrq_index == 0)
8217 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
8219 if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) {
8220 hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index];
8222 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
8223 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8225 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
8227 ioarcb->cmd_pkt.cdb[1] = 0x1;
8229 if (ioa_cfg->nvectors == 1)
8230 ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE;
8232 ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE;
8234 ioarcb->cmd_pkt.cdb[2] =
8235 ((u64) hrrq->host_rrq_dma >> 24) & 0xff;
8236 ioarcb->cmd_pkt.cdb[3] =
8237 ((u64) hrrq->host_rrq_dma >> 16) & 0xff;
8238 ioarcb->cmd_pkt.cdb[4] =
8239 ((u64) hrrq->host_rrq_dma >> 8) & 0xff;
8240 ioarcb->cmd_pkt.cdb[5] =
8241 ((u64) hrrq->host_rrq_dma) & 0xff;
8242 ioarcb->cmd_pkt.cdb[7] =
8243 ((sizeof(u32) * hrrq->size) >> 8) & 0xff;
8244 ioarcb->cmd_pkt.cdb[8] =
8245 (sizeof(u32) * hrrq->size) & 0xff;
8247 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8248 ioarcb->cmd_pkt.cdb[9] =
8249 ioa_cfg->identify_hrrq_index;
8251 if (ioa_cfg->sis64) {
8252 ioarcb->cmd_pkt.cdb[10] =
8253 ((u64) hrrq->host_rrq_dma >> 56) & 0xff;
8254 ioarcb->cmd_pkt.cdb[11] =
8255 ((u64) hrrq->host_rrq_dma >> 48) & 0xff;
8256 ioarcb->cmd_pkt.cdb[12] =
8257 ((u64) hrrq->host_rrq_dma >> 40) & 0xff;
8258 ioarcb->cmd_pkt.cdb[13] =
8259 ((u64) hrrq->host_rrq_dma >> 32) & 0xff;
8262 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8263 ioarcb->cmd_pkt.cdb[14] =
8264 ioa_cfg->identify_hrrq_index;
8266 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
8267 IPR_INTERNAL_TIMEOUT);
8269 if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num)
8270 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8273 return IPR_RC_JOB_RETURN;
8277 return IPR_RC_JOB_CONTINUE;
8281 * ipr_reset_timer_done - Adapter reset timer function
8282 * @t: Timer context used to fetch ipr command struct
8284 * Description: This function is used in adapter reset processing
8285 * for timing events. If the reset_cmd pointer in the IOA
8286 * config struct is not this adapter's we are doing nested
8287 * resets and fail_all_ops will take care of freeing the
8293 static void ipr_reset_timer_done(struct timer_list *t)
8295 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
8296 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8297 unsigned long lock_flags = 0;
8299 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8301 if (ioa_cfg->reset_cmd == ipr_cmd) {
8302 list_del(&ipr_cmd->queue);
8303 ipr_cmd->done(ipr_cmd);
8306 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8310 * ipr_reset_start_timer - Start a timer for adapter reset job
8311 * @ipr_cmd: ipr command struct
8312 * @timeout: timeout value
8314 * Description: This function is used in adapter reset processing
8315 * for timing events. If the reset_cmd pointer in the IOA
8316 * config struct is not this adapter's we are doing nested
8317 * resets and fail_all_ops will take care of freeing the
8323 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
8324 unsigned long timeout)
8328 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8329 ipr_cmd->done = ipr_reset_ioa_job;
8331 ipr_cmd->timer.expires = jiffies + timeout;
8332 ipr_cmd->timer.function = ipr_reset_timer_done;
8333 add_timer(&ipr_cmd->timer);
8337 * ipr_init_ioa_mem - Initialize ioa_cfg control block
8338 * @ioa_cfg: ioa cfg struct
8343 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
8345 struct ipr_hrr_queue *hrrq;
8347 for_each_hrrq(hrrq, ioa_cfg) {
8348 spin_lock(&hrrq->_lock);
8349 memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size);
8351 /* Initialize Host RRQ pointers */
8352 hrrq->hrrq_start = hrrq->host_rrq;
8353 hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1];
8354 hrrq->hrrq_curr = hrrq->hrrq_start;
8355 hrrq->toggle_bit = 1;
8356 spin_unlock(&hrrq->_lock);
8360 ioa_cfg->identify_hrrq_index = 0;
8361 if (ioa_cfg->hrrq_num == 1)
8362 atomic_set(&ioa_cfg->hrrq_index, 0);
8364 atomic_set(&ioa_cfg->hrrq_index, 1);
8366 /* Zero out config table */
8367 memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
8371 * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8372 * @ipr_cmd: ipr command struct
8375 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8377 static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
8379 unsigned long stage, stage_time;
8381 volatile u32 int_reg;
8382 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8385 feedback = readl(ioa_cfg->regs.init_feedback_reg);
8386 stage = feedback & IPR_IPL_INIT_STAGE_MASK;
8387 stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
8389 ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
8391 /* sanity check the stage_time value */
8392 if (stage_time == 0)
8393 stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
8394 else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
8395 stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
8396 else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
8397 stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
8399 if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
8400 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
8401 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8402 stage_time = ioa_cfg->transop_timeout;
8403 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8404 } else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
8405 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8406 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8407 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8408 maskval = IPR_PCII_IPL_STAGE_CHANGE;
8409 maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
8410 writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
8411 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8412 return IPR_RC_JOB_CONTINUE;
8416 ipr_cmd->timer.expires = jiffies + stage_time * HZ;
8417 ipr_cmd->timer.function = ipr_oper_timeout;
8418 ipr_cmd->done = ipr_reset_ioa_job;
8419 add_timer(&ipr_cmd->timer);
8421 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8423 return IPR_RC_JOB_RETURN;
8427 * ipr_reset_enable_ioa - Enable the IOA following a reset.
8428 * @ipr_cmd: ipr command struct
8430 * This function reinitializes some control blocks and
8431 * enables destructive diagnostics on the adapter.
8436 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
8438 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8439 volatile u32 int_reg;
8440 volatile u64 maskval;
8444 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8445 ipr_init_ioa_mem(ioa_cfg);
8447 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
8448 spin_lock(&ioa_cfg->hrrq[i]._lock);
8449 ioa_cfg->hrrq[i].allow_interrupts = 1;
8450 spin_unlock(&ioa_cfg->hrrq[i]._lock);
8452 if (ioa_cfg->sis64) {
8453 /* Set the adapter to the correct endian mode. */
8454 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8455 int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8458 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8460 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8461 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
8462 ioa_cfg->regs.clr_interrupt_mask_reg32);
8463 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8464 return IPR_RC_JOB_CONTINUE;
8467 /* Enable destructive diagnostics on IOA */
8468 writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
8470 if (ioa_cfg->sis64) {
8471 maskval = IPR_PCII_IPL_STAGE_CHANGE;
8472 maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
8473 writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
8475 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
8477 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8479 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
8481 if (ioa_cfg->sis64) {
8482 ipr_cmd->job_step = ipr_reset_next_stage;
8483 return IPR_RC_JOB_CONTINUE;
8486 ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
8487 ipr_cmd->timer.function = ipr_oper_timeout;
8488 ipr_cmd->done = ipr_reset_ioa_job;
8489 add_timer(&ipr_cmd->timer);
8490 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8493 return IPR_RC_JOB_RETURN;
8497 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8498 * @ipr_cmd: ipr command struct
8500 * This function is invoked when an adapter dump has run out
8501 * of processing time.
8504 * IPR_RC_JOB_CONTINUE
8506 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
8508 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8510 if (ioa_cfg->sdt_state == GET_DUMP)
8511 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8512 else if (ioa_cfg->sdt_state == READ_DUMP)
8513 ioa_cfg->sdt_state = ABORT_DUMP;
8515 ioa_cfg->dump_timeout = 1;
8516 ipr_cmd->job_step = ipr_reset_alert;
8518 return IPR_RC_JOB_CONTINUE;
8522 * ipr_unit_check_no_data - Log a unit check/no data error log
8523 * @ioa_cfg: ioa config struct
8525 * Logs an error indicating the adapter unit checked, but for some
8526 * reason, we were unable to fetch the unit check buffer.
8531 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
8533 ioa_cfg->errors_logged++;
8534 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
8538 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8539 * @ioa_cfg: ioa config struct
8541 * Fetches the unit check buffer from the adapter by clocking the data
8542 * through the mailbox register.
8547 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
8549 unsigned long mailbox;
8550 struct ipr_hostrcb *hostrcb;
8551 struct ipr_uc_sdt sdt;
8555 mailbox = readl(ioa_cfg->ioa_mailbox);
8557 if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
8558 ipr_unit_check_no_data(ioa_cfg);
8562 memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
8563 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
8564 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
8566 if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
8567 ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
8568 (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
8569 ipr_unit_check_no_data(ioa_cfg);
8573 /* Find length of the first sdt entry (UC buffer) */
8574 if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
8575 length = be32_to_cpu(sdt.entry[0].end_token);
8577 length = (be32_to_cpu(sdt.entry[0].end_token) -
8578 be32_to_cpu(sdt.entry[0].start_token)) &
8579 IPR_FMT2_MBX_ADDR_MASK;
8581 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
8582 struct ipr_hostrcb, queue);
8583 list_del_init(&hostrcb->queue);
8584 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
8586 rc = ipr_get_ldump_data_section(ioa_cfg,
8587 be32_to_cpu(sdt.entry[0].start_token),
8588 (__be32 *)&hostrcb->hcam,
8589 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
8592 ipr_handle_log_data(ioa_cfg, hostrcb);
8593 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
8594 if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
8595 ioa_cfg->sdt_state == GET_DUMP)
8596 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8598 ipr_unit_check_no_data(ioa_cfg);
8600 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
8604 * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8605 * @ipr_cmd: ipr command struct
8607 * Description: This function will call to get the unit check buffer.
8612 static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
8614 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8617 ioa_cfg->ioa_unit_checked = 0;
8618 ipr_get_unit_check_buffer(ioa_cfg);
8619 ipr_cmd->job_step = ipr_reset_alert;
8620 ipr_reset_start_timer(ipr_cmd, 0);
8623 return IPR_RC_JOB_RETURN;
8626 static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd)
8628 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8632 if (ioa_cfg->sdt_state != GET_DUMP)
8633 return IPR_RC_JOB_RETURN;
8635 if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left ||
8636 (readl(ioa_cfg->regs.sense_interrupt_reg) &
8637 IPR_PCII_MAILBOX_STABLE)) {
8639 if (!ipr_cmd->u.time_left)
8640 dev_err(&ioa_cfg->pdev->dev,
8641 "Timed out waiting for Mailbox register.\n");
8643 ioa_cfg->sdt_state = READ_DUMP;
8644 ioa_cfg->dump_timeout = 0;
8646 ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
8648 ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
8649 ipr_cmd->job_step = ipr_reset_wait_for_dump;
8650 schedule_work(&ioa_cfg->work_q);
8653 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8654 ipr_reset_start_timer(ipr_cmd,
8655 IPR_CHECK_FOR_RESET_TIMEOUT);
8659 return IPR_RC_JOB_RETURN;
8663 * ipr_reset_restore_cfg_space - Restore PCI config space.
8664 * @ipr_cmd: ipr command struct
8666 * Description: This function restores the saved PCI config space of
8667 * the adapter, fails all outstanding ops back to the callers, and
8668 * fetches the dump/unit check if applicable to this reset.
8671 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8673 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
8675 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8678 ioa_cfg->pdev->state_saved = true;
8679 pci_restore_state(ioa_cfg->pdev);
8681 if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
8682 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8683 return IPR_RC_JOB_CONTINUE;
8686 ipr_fail_all_ops(ioa_cfg);
8688 if (ioa_cfg->sis64) {
8689 /* Set the adapter to the correct endian mode. */
8690 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8691 readl(ioa_cfg->regs.endian_swap_reg);
8694 if (ioa_cfg->ioa_unit_checked) {
8695 if (ioa_cfg->sis64) {
8696 ipr_cmd->job_step = ipr_reset_get_unit_check_job;
8697 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
8698 return IPR_RC_JOB_RETURN;
8700 ioa_cfg->ioa_unit_checked = 0;
8701 ipr_get_unit_check_buffer(ioa_cfg);
8702 ipr_cmd->job_step = ipr_reset_alert;
8703 ipr_reset_start_timer(ipr_cmd, 0);
8704 return IPR_RC_JOB_RETURN;
8708 if (ioa_cfg->in_ioa_bringdown) {
8709 ipr_cmd->job_step = ipr_ioa_bringdown_done;
8710 } else if (ioa_cfg->sdt_state == GET_DUMP) {
8711 ipr_cmd->job_step = ipr_dump_mailbox_wait;
8712 ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX;
8714 ipr_cmd->job_step = ipr_reset_enable_ioa;
8718 return IPR_RC_JOB_CONTINUE;
8722 * ipr_reset_bist_done - BIST has completed on the adapter.
8723 * @ipr_cmd: ipr command struct
8725 * Description: Unblock config space and resume the reset process.
8728 * IPR_RC_JOB_CONTINUE
8730 static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
8732 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8735 if (ioa_cfg->cfg_locked)
8736 pci_cfg_access_unlock(ioa_cfg->pdev);
8737 ioa_cfg->cfg_locked = 0;
8738 ipr_cmd->job_step = ipr_reset_restore_cfg_space;
8740 return IPR_RC_JOB_CONTINUE;
8744 * ipr_reset_start_bist - Run BIST on the adapter.
8745 * @ipr_cmd: ipr command struct
8747 * Description: This function runs BIST on the adapter, then delays 2 seconds.
8750 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8752 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
8754 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8755 int rc = PCIBIOS_SUCCESSFUL;
8758 if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO)
8759 writel(IPR_UPROCI_SIS64_START_BIST,
8760 ioa_cfg->regs.set_uproc_interrupt_reg32);
8762 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
8764 if (rc == PCIBIOS_SUCCESSFUL) {
8765 ipr_cmd->job_step = ipr_reset_bist_done;
8766 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8767 rc = IPR_RC_JOB_RETURN;
8769 if (ioa_cfg->cfg_locked)
8770 pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev);
8771 ioa_cfg->cfg_locked = 0;
8772 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8773 rc = IPR_RC_JOB_CONTINUE;
8781 * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8782 * @ipr_cmd: ipr command struct
8784 * Description: This clears PCI reset to the adapter and delays two seconds.
8789 static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
8792 ipr_cmd->job_step = ipr_reset_bist_done;
8793 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8795 return IPR_RC_JOB_RETURN;
8799 * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8800 * @work: work struct
8802 * Description: This pulses warm reset to a slot.
8805 static void ipr_reset_reset_work(struct work_struct *work)
8807 struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work);
8808 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8809 struct pci_dev *pdev = ioa_cfg->pdev;
8810 unsigned long lock_flags = 0;
8813 pci_set_pcie_reset_state(pdev, pcie_warm_reset);
8814 msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT));
8815 pci_set_pcie_reset_state(pdev, pcie_deassert_reset);
8817 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8818 if (ioa_cfg->reset_cmd == ipr_cmd)
8819 ipr_reset_ioa_job(ipr_cmd);
8820 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8825 * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8826 * @ipr_cmd: ipr command struct
8828 * Description: This asserts PCI reset to the adapter.
8833 static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
8835 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8838 INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work);
8839 queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work);
8840 ipr_cmd->job_step = ipr_reset_slot_reset_done;
8842 return IPR_RC_JOB_RETURN;
8846 * ipr_reset_block_config_access_wait - Wait for permission to block config access
8847 * @ipr_cmd: ipr command struct
8849 * Description: This attempts to block config access to the IOA.
8852 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8854 static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd)
8856 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8857 int rc = IPR_RC_JOB_CONTINUE;
8859 if (pci_cfg_access_trylock(ioa_cfg->pdev)) {
8860 ioa_cfg->cfg_locked = 1;
8861 ipr_cmd->job_step = ioa_cfg->reset;
8863 if (ipr_cmd->u.time_left) {
8864 rc = IPR_RC_JOB_RETURN;
8865 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8866 ipr_reset_start_timer(ipr_cmd,
8867 IPR_CHECK_FOR_RESET_TIMEOUT);
8869 ipr_cmd->job_step = ioa_cfg->reset;
8870 dev_err(&ioa_cfg->pdev->dev,
8871 "Timed out waiting to lock config access. Resetting anyway.\n");
8879 * ipr_reset_block_config_access - Block config access to the IOA
8880 * @ipr_cmd: ipr command struct
8882 * Description: This attempts to block config access to the IOA
8885 * IPR_RC_JOB_CONTINUE
8887 static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd)
8889 ipr_cmd->ioa_cfg->cfg_locked = 0;
8890 ipr_cmd->job_step = ipr_reset_block_config_access_wait;
8891 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8892 return IPR_RC_JOB_CONTINUE;
8896 * ipr_reset_allowed - Query whether or not IOA can be reset
8897 * @ioa_cfg: ioa config struct
8900 * 0 if reset not allowed / non-zero if reset is allowed
8902 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
8904 volatile u32 temp_reg;
8906 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
8907 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
8911 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8912 * @ipr_cmd: ipr command struct
8914 * Description: This function waits for adapter permission to run BIST,
8915 * then runs BIST. If the adapter does not give permission after a
8916 * reasonable time, we will reset the adapter anyway. The impact of
8917 * resetting the adapter without warning the adapter is the risk of
8918 * losing the persistent error log on the adapter. If the adapter is
8919 * reset while it is writing to the flash on the adapter, the flash
8920 * segment will have bad ECC and be zeroed.
8923 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8925 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
8927 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8928 int rc = IPR_RC_JOB_RETURN;
8930 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
8931 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8932 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8934 ipr_cmd->job_step = ipr_reset_block_config_access;
8935 rc = IPR_RC_JOB_CONTINUE;
8942 * ipr_reset_alert - Alert the adapter of a pending reset
8943 * @ipr_cmd: ipr command struct
8945 * Description: This function alerts the adapter that it will be reset.
8946 * If memory space is not currently enabled, proceed directly
8947 * to running BIST on the adapter. The timer must always be started
8948 * so we guarantee we do not run BIST from ipr_isr.
8953 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
8955 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8960 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
8962 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
8963 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
8964 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
8965 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
8967 ipr_cmd->job_step = ipr_reset_block_config_access;
8970 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8971 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8974 return IPR_RC_JOB_RETURN;
8978 * ipr_reset_quiesce_done - Complete IOA disconnect
8979 * @ipr_cmd: ipr command struct
8981 * Description: Freeze the adapter to complete quiesce processing
8984 * IPR_RC_JOB_CONTINUE
8986 static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd)
8988 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8991 ipr_cmd->job_step = ipr_ioa_bringdown_done;
8992 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
8994 return IPR_RC_JOB_CONTINUE;
8998 * ipr_reset_cancel_hcam_done - Check for outstanding commands
8999 * @ipr_cmd: ipr command struct
9001 * Description: Ensure nothing is outstanding to the IOA and
9002 * proceed with IOA disconnect. Otherwise reset the IOA.
9005 * IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
9007 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd)
9009 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9010 struct ipr_cmnd *loop_cmd;
9011 struct ipr_hrr_queue *hrrq;
9012 int rc = IPR_RC_JOB_CONTINUE;
9016 ipr_cmd->job_step = ipr_reset_quiesce_done;
9018 for_each_hrrq(hrrq, ioa_cfg) {
9019 spin_lock(&hrrq->_lock);
9020 list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) {
9022 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9023 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9024 rc = IPR_RC_JOB_RETURN;
9027 spin_unlock(&hrrq->_lock);
9038 * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
9039 * @ipr_cmd: ipr command struct
9041 * Description: Cancel any oustanding HCAMs to the IOA.
9044 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9046 static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd)
9048 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9049 int rc = IPR_RC_JOB_CONTINUE;
9050 struct ipr_cmd_pkt *cmd_pkt;
9051 struct ipr_cmnd *hcam_cmd;
9052 struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ];
9055 ipr_cmd->job_step = ipr_reset_cancel_hcam_done;
9057 if (!hrrq->ioa_is_dead) {
9058 if (!list_empty(&ioa_cfg->hostrcb_pending_q)) {
9059 list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) {
9060 if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC)
9063 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9064 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9065 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
9066 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
9067 cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST;
9068 cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB;
9069 cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff;
9070 cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff;
9071 cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff;
9072 cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff;
9073 cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff;
9074 cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff;
9075 cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff;
9076 cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff;
9078 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9079 IPR_CANCEL_TIMEOUT);
9081 rc = IPR_RC_JOB_RETURN;
9082 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9087 ipr_cmd->job_step = ipr_reset_alert;
9094 * ipr_reset_ucode_download_done - Microcode download completion
9095 * @ipr_cmd: ipr command struct
9097 * Description: This function unmaps the microcode download buffer.
9100 * IPR_RC_JOB_CONTINUE
9102 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
9104 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9105 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9107 dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
9108 sglist->num_sg, DMA_TO_DEVICE);
9110 ipr_cmd->job_step = ipr_reset_alert;
9111 return IPR_RC_JOB_CONTINUE;
9115 * ipr_reset_ucode_download - Download microcode to the adapter
9116 * @ipr_cmd: ipr command struct
9118 * Description: This function checks to see if it there is microcode
9119 * to download to the adapter. If there is, a download is performed.
9122 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9124 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
9126 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9127 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9130 ipr_cmd->job_step = ipr_reset_alert;
9133 return IPR_RC_JOB_CONTINUE;
9135 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9136 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
9137 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
9138 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
9139 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
9140 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
9141 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
9144 ipr_build_ucode_ioadl64(ipr_cmd, sglist);
9146 ipr_build_ucode_ioadl(ipr_cmd, sglist);
9147 ipr_cmd->job_step = ipr_reset_ucode_download_done;
9149 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9150 IPR_WRITE_BUFFER_TIMEOUT);
9153 return IPR_RC_JOB_RETURN;
9157 * ipr_reset_shutdown_ioa - Shutdown the adapter
9158 * @ipr_cmd: ipr command struct
9160 * Description: This function issues an adapter shutdown of the
9161 * specified type to the specified adapter as part of the
9162 * adapter reset job.
9165 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9167 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
9169 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9170 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
9171 unsigned long timeout;
9172 int rc = IPR_RC_JOB_CONTINUE;
9175 if (shutdown_type == IPR_SHUTDOWN_QUIESCE)
9176 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9177 else if (shutdown_type != IPR_SHUTDOWN_NONE &&
9178 !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
9179 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9180 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9181 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
9182 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
9184 if (shutdown_type == IPR_SHUTDOWN_NORMAL)
9185 timeout = IPR_SHUTDOWN_TIMEOUT;
9186 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
9187 timeout = IPR_INTERNAL_TIMEOUT;
9188 else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
9189 timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
9191 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
9193 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
9195 rc = IPR_RC_JOB_RETURN;
9196 ipr_cmd->job_step = ipr_reset_ucode_download;
9198 ipr_cmd->job_step = ipr_reset_alert;
9205 * ipr_reset_ioa_job - Adapter reset job
9206 * @ipr_cmd: ipr command struct
9208 * Description: This function is the job router for the adapter reset job.
9213 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
9216 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9219 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
9221 if (ioa_cfg->reset_cmd != ipr_cmd) {
9223 * We are doing nested adapter resets and this is
9224 * not the current reset job.
9226 list_add_tail(&ipr_cmd->queue,
9227 &ipr_cmd->hrrq->hrrq_free_q);
9231 if (IPR_IOASC_SENSE_KEY(ioasc)) {
9232 rc = ipr_cmd->job_step_failed(ipr_cmd);
9233 if (rc == IPR_RC_JOB_RETURN)
9237 ipr_reinit_ipr_cmnd(ipr_cmd);
9238 ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
9239 rc = ipr_cmd->job_step(ipr_cmd);
9240 } while (rc == IPR_RC_JOB_CONTINUE);
9244 * _ipr_initiate_ioa_reset - Initiate an adapter reset
9245 * @ioa_cfg: ioa config struct
9246 * @job_step: first job step of reset job
9247 * @shutdown_type: shutdown type
9249 * Description: This function will initiate the reset of the given adapter
9250 * starting at the selected job step.
9251 * If the caller needs to wait on the completion of the reset,
9252 * the caller must sleep on the reset_wait_q.
9257 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9258 int (*job_step) (struct ipr_cmnd *),
9259 enum ipr_shutdown_type shutdown_type)
9261 struct ipr_cmnd *ipr_cmd;
9264 ioa_cfg->in_reset_reload = 1;
9265 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9266 spin_lock(&ioa_cfg->hrrq[i]._lock);
9267 ioa_cfg->hrrq[i].allow_cmds = 0;
9268 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9271 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9272 ioa_cfg->scsi_unblock = 0;
9273 ioa_cfg->scsi_blocked = 1;
9274 scsi_block_requests(ioa_cfg->host);
9277 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
9278 ioa_cfg->reset_cmd = ipr_cmd;
9279 ipr_cmd->job_step = job_step;
9280 ipr_cmd->u.shutdown_type = shutdown_type;
9282 ipr_reset_ioa_job(ipr_cmd);
9286 * ipr_initiate_ioa_reset - Initiate an adapter reset
9287 * @ioa_cfg: ioa config struct
9288 * @shutdown_type: shutdown type
9290 * Description: This function will initiate the reset of the given adapter.
9291 * If the caller needs to wait on the completion of the reset,
9292 * the caller must sleep on the reset_wait_q.
9297 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9298 enum ipr_shutdown_type shutdown_type)
9302 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
9305 if (ioa_cfg->in_reset_reload) {
9306 if (ioa_cfg->sdt_state == GET_DUMP)
9307 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
9308 else if (ioa_cfg->sdt_state == READ_DUMP)
9309 ioa_cfg->sdt_state = ABORT_DUMP;
9312 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
9313 dev_err(&ioa_cfg->pdev->dev,
9314 "IOA taken offline - error recovery failed\n");
9316 ioa_cfg->reset_retries = 0;
9317 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9318 spin_lock(&ioa_cfg->hrrq[i]._lock);
9319 ioa_cfg->hrrq[i].ioa_is_dead = 1;
9320 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9324 if (ioa_cfg->in_ioa_bringdown) {
9325 ioa_cfg->reset_cmd = NULL;
9326 ioa_cfg->in_reset_reload = 0;
9327 ipr_fail_all_ops(ioa_cfg);
9328 wake_up_all(&ioa_cfg->reset_wait_q);
9330 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9331 ioa_cfg->scsi_unblock = 1;
9332 schedule_work(&ioa_cfg->work_q);
9336 ioa_cfg->in_ioa_bringdown = 1;
9337 shutdown_type = IPR_SHUTDOWN_NONE;
9341 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
9346 * ipr_reset_freeze - Hold off all I/O activity
9347 * @ipr_cmd: ipr command struct
9349 * Description: If the PCI slot is frozen, hold off all I/O
9350 * activity; then, as soon as the slot is available again,
9351 * initiate an adapter reset.
9353 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
9355 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9358 /* Disallow new interrupts, avoid loop */
9359 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9360 spin_lock(&ioa_cfg->hrrq[i]._lock);
9361 ioa_cfg->hrrq[i].allow_interrupts = 0;
9362 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9365 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
9366 ipr_cmd->done = ipr_reset_ioa_job;
9367 return IPR_RC_JOB_RETURN;
9371 * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9372 * @pdev: PCI device struct
9374 * Description: This routine is called to tell us that the MMIO
9375 * access to the IOA has been restored
9377 static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev)
9379 unsigned long flags = 0;
9380 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9382 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9383 if (!ioa_cfg->probe_done)
9384 pci_save_state(pdev);
9385 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9386 return PCI_ERS_RESULT_NEED_RESET;
9390 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9391 * @pdev: PCI device struct
9393 * Description: This routine is called to tell us that the PCI bus
9394 * is down. Can't do anything here, except put the device driver
9395 * into a holding pattern, waiting for the PCI bus to come back.
9397 static void ipr_pci_frozen(struct pci_dev *pdev)
9399 unsigned long flags = 0;
9400 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9402 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9403 if (ioa_cfg->probe_done)
9404 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
9405 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9409 * ipr_pci_slot_reset - Called when PCI slot has been reset.
9410 * @pdev: PCI device struct
9412 * Description: This routine is called by the pci error recovery
9413 * code after the PCI slot has been reset, just before we
9414 * should resume normal operations.
9416 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
9418 unsigned long flags = 0;
9419 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9421 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9422 if (ioa_cfg->probe_done) {
9423 if (ioa_cfg->needs_warm_reset)
9424 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9426 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
9429 wake_up_all(&ioa_cfg->eeh_wait_q);
9430 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9431 return PCI_ERS_RESULT_RECOVERED;
9435 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9436 * @pdev: PCI device struct
9438 * Description: This routine is called when the PCI bus has
9439 * permanently failed.
9441 static void ipr_pci_perm_failure(struct pci_dev *pdev)
9443 unsigned long flags = 0;
9444 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9447 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9448 if (ioa_cfg->probe_done) {
9449 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
9450 ioa_cfg->sdt_state = ABORT_DUMP;
9451 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
9452 ioa_cfg->in_ioa_bringdown = 1;
9453 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9454 spin_lock(&ioa_cfg->hrrq[i]._lock);
9455 ioa_cfg->hrrq[i].allow_cmds = 0;
9456 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9459 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9461 wake_up_all(&ioa_cfg->eeh_wait_q);
9462 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9466 * ipr_pci_error_detected - Called when a PCI error is detected.
9467 * @pdev: PCI device struct
9468 * @state: PCI channel state
9470 * Description: Called when a PCI error is detected.
9473 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9475 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
9476 pci_channel_state_t state)
9479 case pci_channel_io_frozen:
9480 ipr_pci_frozen(pdev);
9481 return PCI_ERS_RESULT_CAN_RECOVER;
9482 case pci_channel_io_perm_failure:
9483 ipr_pci_perm_failure(pdev);
9484 return PCI_ERS_RESULT_DISCONNECT;
9488 return PCI_ERS_RESULT_NEED_RESET;
9492 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9493 * @ioa_cfg: ioa cfg struct
9495 * Description: This is the second phase of adapter initialization
9496 * This function takes care of initilizing the adapter to the point
9497 * where it can accept new commands.
9501 static void ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
9503 unsigned long host_lock_flags = 0;
9506 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
9507 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
9508 ioa_cfg->probe_done = 1;
9509 if (ioa_cfg->needs_hard_reset) {
9510 ioa_cfg->needs_hard_reset = 0;
9511 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9513 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
9515 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
9521 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9522 * @ioa_cfg: ioa config struct
9527 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9531 if (ioa_cfg->ipr_cmnd_list) {
9532 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9533 if (ioa_cfg->ipr_cmnd_list[i])
9534 dma_pool_free(ioa_cfg->ipr_cmd_pool,
9535 ioa_cfg->ipr_cmnd_list[i],
9536 ioa_cfg->ipr_cmnd_list_dma[i]);
9538 ioa_cfg->ipr_cmnd_list[i] = NULL;
9542 dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
9544 kfree(ioa_cfg->ipr_cmnd_list);
9545 kfree(ioa_cfg->ipr_cmnd_list_dma);
9546 ioa_cfg->ipr_cmnd_list = NULL;
9547 ioa_cfg->ipr_cmnd_list_dma = NULL;
9548 ioa_cfg->ipr_cmd_pool = NULL;
9552 * ipr_free_mem - Frees memory allocated for an adapter
9553 * @ioa_cfg: ioa cfg struct
9558 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
9562 kfree(ioa_cfg->res_entries);
9563 dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
9564 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9565 ipr_free_cmd_blks(ioa_cfg);
9567 for (i = 0; i < ioa_cfg->hrrq_num; i++)
9568 dma_free_coherent(&ioa_cfg->pdev->dev,
9569 sizeof(u32) * ioa_cfg->hrrq[i].size,
9570 ioa_cfg->hrrq[i].host_rrq,
9571 ioa_cfg->hrrq[i].host_rrq_dma);
9573 dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
9574 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9576 for (i = 0; i < IPR_MAX_HCAMS; i++) {
9577 dma_free_coherent(&ioa_cfg->pdev->dev,
9578 sizeof(struct ipr_hostrcb),
9579 ioa_cfg->hostrcb[i],
9580 ioa_cfg->hostrcb_dma[i]);
9583 ipr_free_dump(ioa_cfg);
9584 kfree(ioa_cfg->trace);
9588 * ipr_free_irqs - Free all allocated IRQs for the adapter.
9589 * @ioa_cfg: ipr cfg struct
9591 * This function frees all allocated IRQs for the
9592 * specified adapter.
9597 static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg)
9599 struct pci_dev *pdev = ioa_cfg->pdev;
9602 for (i = 0; i < ioa_cfg->nvectors; i++)
9603 free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]);
9604 pci_free_irq_vectors(pdev);
9608 * ipr_free_all_resources - Free all allocated resources for an adapter.
9609 * @ioa_cfg: ioa config struct
9611 * This function frees all allocated resources for the
9612 * specified adapter.
9617 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
9619 struct pci_dev *pdev = ioa_cfg->pdev;
9622 ipr_free_irqs(ioa_cfg);
9623 if (ioa_cfg->reset_work_q)
9624 destroy_workqueue(ioa_cfg->reset_work_q);
9625 iounmap(ioa_cfg->hdw_dma_regs);
9626 pci_release_regions(pdev);
9627 ipr_free_mem(ioa_cfg);
9628 scsi_host_put(ioa_cfg->host);
9629 pci_disable_device(pdev);
9634 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9635 * @ioa_cfg: ioa config struct
9638 * 0 on success / -ENOMEM on allocation failure
9640 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9642 struct ipr_cmnd *ipr_cmd;
9643 struct ipr_ioarcb *ioarcb;
9644 dma_addr_t dma_addr;
9645 int i, entries_each_hrrq, hrrq_id = 0;
9647 ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
9648 sizeof(struct ipr_cmnd), 512, 0);
9650 if (!ioa_cfg->ipr_cmd_pool)
9653 ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL);
9654 ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL);
9656 if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
9657 ipr_free_cmd_blks(ioa_cfg);
9661 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9662 if (ioa_cfg->hrrq_num > 1) {
9664 entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS;
9665 ioa_cfg->hrrq[i].min_cmd_id = 0;
9666 ioa_cfg->hrrq[i].max_cmd_id =
9667 (entries_each_hrrq - 1);
9670 IPR_NUM_BASE_CMD_BLKS/
9671 (ioa_cfg->hrrq_num - 1);
9672 ioa_cfg->hrrq[i].min_cmd_id =
9673 IPR_NUM_INTERNAL_CMD_BLKS +
9674 (i - 1) * entries_each_hrrq;
9675 ioa_cfg->hrrq[i].max_cmd_id =
9676 (IPR_NUM_INTERNAL_CMD_BLKS +
9677 i * entries_each_hrrq - 1);
9680 entries_each_hrrq = IPR_NUM_CMD_BLKS;
9681 ioa_cfg->hrrq[i].min_cmd_id = 0;
9682 ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1);
9684 ioa_cfg->hrrq[i].size = entries_each_hrrq;
9687 BUG_ON(ioa_cfg->hrrq_num == 0);
9689 i = IPR_NUM_CMD_BLKS -
9690 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1;
9692 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i;
9693 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i;
9696 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9697 ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool,
9698 GFP_KERNEL, &dma_addr);
9701 ipr_free_cmd_blks(ioa_cfg);
9705 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
9706 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
9708 ioarcb = &ipr_cmd->ioarcb;
9709 ipr_cmd->dma_addr = dma_addr;
9711 ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
9713 ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
9715 ioarcb->host_response_handle = cpu_to_be32(i << 2);
9716 if (ioa_cfg->sis64) {
9717 ioarcb->u.sis64_addr_data.data_ioadl_addr =
9718 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
9719 ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
9720 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
9722 ioarcb->write_ioadl_addr =
9723 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
9724 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
9725 ioarcb->ioasa_host_pci_addr =
9726 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
9728 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
9729 ipr_cmd->cmd_index = i;
9730 ipr_cmd->ioa_cfg = ioa_cfg;
9731 ipr_cmd->sense_buffer_dma = dma_addr +
9732 offsetof(struct ipr_cmnd, sense_buffer);
9734 ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id;
9735 ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id];
9736 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9737 if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id)
9745 * ipr_alloc_mem - Allocate memory for an adapter
9746 * @ioa_cfg: ioa config struct
9749 * 0 on success / non-zero for error
9751 static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
9753 struct pci_dev *pdev = ioa_cfg->pdev;
9754 int i, rc = -ENOMEM;
9757 ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported,
9758 sizeof(struct ipr_resource_entry),
9761 if (!ioa_cfg->res_entries)
9764 for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
9765 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
9766 ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
9769 ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
9770 sizeof(struct ipr_misc_cbs),
9771 &ioa_cfg->vpd_cbs_dma,
9774 if (!ioa_cfg->vpd_cbs)
9775 goto out_free_res_entries;
9777 if (ipr_alloc_cmd_blks(ioa_cfg))
9778 goto out_free_vpd_cbs;
9780 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9781 ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
9782 sizeof(u32) * ioa_cfg->hrrq[i].size,
9783 &ioa_cfg->hrrq[i].host_rrq_dma,
9786 if (!ioa_cfg->hrrq[i].host_rrq) {
9788 dma_free_coherent(&pdev->dev,
9789 sizeof(u32) * ioa_cfg->hrrq[i].size,
9790 ioa_cfg->hrrq[i].host_rrq,
9791 ioa_cfg->hrrq[i].host_rrq_dma);
9792 goto out_ipr_free_cmd_blocks;
9794 ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
9797 ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
9798 ioa_cfg->cfg_table_size,
9799 &ioa_cfg->cfg_table_dma,
9802 if (!ioa_cfg->u.cfg_table)
9803 goto out_free_host_rrq;
9805 for (i = 0; i < IPR_MAX_HCAMS; i++) {
9806 ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
9807 sizeof(struct ipr_hostrcb),
9808 &ioa_cfg->hostrcb_dma[i],
9811 if (!ioa_cfg->hostrcb[i])
9812 goto out_free_hostrcb_dma;
9814 ioa_cfg->hostrcb[i]->hostrcb_dma =
9815 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
9816 ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
9817 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
9820 ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES,
9821 sizeof(struct ipr_trace_entry),
9824 if (!ioa_cfg->trace)
9825 goto out_free_hostrcb_dma;
9832 out_free_hostrcb_dma:
9834 dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
9835 ioa_cfg->hostrcb[i],
9836 ioa_cfg->hostrcb_dma[i]);
9838 dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
9839 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9841 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9842 dma_free_coherent(&pdev->dev,
9843 sizeof(u32) * ioa_cfg->hrrq[i].size,
9844 ioa_cfg->hrrq[i].host_rrq,
9845 ioa_cfg->hrrq[i].host_rrq_dma);
9847 out_ipr_free_cmd_blocks:
9848 ipr_free_cmd_blks(ioa_cfg);
9850 dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
9851 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9852 out_free_res_entries:
9853 kfree(ioa_cfg->res_entries);
9858 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9859 * @ioa_cfg: ioa config struct
9864 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
9868 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
9869 ioa_cfg->bus_attr[i].bus = i;
9870 ioa_cfg->bus_attr[i].qas_enabled = 0;
9871 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
9872 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
9873 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
9875 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
9880 * ipr_init_regs - Initialize IOA registers
9881 * @ioa_cfg: ioa config struct
9886 static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg)
9888 const struct ipr_interrupt_offsets *p;
9889 struct ipr_interrupts *t;
9892 p = &ioa_cfg->chip_cfg->regs;
9894 base = ioa_cfg->hdw_dma_regs;
9896 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
9897 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
9898 t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
9899 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
9900 t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
9901 t->clr_interrupt_reg = base + p->clr_interrupt_reg;
9902 t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
9903 t->sense_interrupt_reg = base + p->sense_interrupt_reg;
9904 t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
9905 t->ioarrin_reg = base + p->ioarrin_reg;
9906 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
9907 t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
9908 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
9909 t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
9910 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
9911 t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
9913 if (ioa_cfg->sis64) {
9914 t->init_feedback_reg = base + p->init_feedback_reg;
9915 t->dump_addr_reg = base + p->dump_addr_reg;
9916 t->dump_data_reg = base + p->dump_data_reg;
9917 t->endian_swap_reg = base + p->endian_swap_reg;
9922 * ipr_init_ioa_cfg - Initialize IOA config struct
9923 * @ioa_cfg: ioa config struct
9924 * @host: scsi host struct
9925 * @pdev: PCI dev struct
9930 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
9931 struct Scsi_Host *host, struct pci_dev *pdev)
9935 ioa_cfg->host = host;
9936 ioa_cfg->pdev = pdev;
9937 ioa_cfg->log_level = ipr_log_level;
9938 ioa_cfg->doorbell = IPR_DOORBELL;
9939 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
9940 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
9941 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
9942 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
9943 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
9944 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
9946 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
9947 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
9948 INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q);
9949 INIT_LIST_HEAD(&ioa_cfg->free_res_q);
9950 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
9951 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
9952 INIT_WORK(&ioa_cfg->scsi_add_work_q, ipr_add_remove_thread);
9953 init_waitqueue_head(&ioa_cfg->reset_wait_q);
9954 init_waitqueue_head(&ioa_cfg->msi_wait_q);
9955 init_waitqueue_head(&ioa_cfg->eeh_wait_q);
9956 ioa_cfg->sdt_state = INACTIVE;
9958 ipr_initialize_bus_attr(ioa_cfg);
9959 ioa_cfg->max_devs_supported = ipr_max_devs;
9961 if (ioa_cfg->sis64) {
9962 host->max_channel = IPR_MAX_SIS64_BUSES;
9963 host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
9964 host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
9965 if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
9966 ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
9967 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
9968 + ((sizeof(struct ipr_config_table_entry64)
9969 * ioa_cfg->max_devs_supported)));
9971 host->max_channel = IPR_VSET_BUS;
9972 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
9973 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
9974 if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
9975 ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
9976 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
9977 + ((sizeof(struct ipr_config_table_entry)
9978 * ioa_cfg->max_devs_supported)));
9981 host->unique_id = host->host_no;
9982 host->max_cmd_len = IPR_MAX_CDB_LEN;
9983 host->can_queue = ioa_cfg->max_cmds;
9984 pci_set_drvdata(pdev, ioa_cfg);
9986 for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) {
9987 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q);
9988 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q);
9989 spin_lock_init(&ioa_cfg->hrrq[i]._lock);
9991 ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock;
9993 ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock;
9998 * ipr_get_chip_info - Find adapter chip information
9999 * @dev_id: PCI device id struct
10002 * ptr to chip information on success / NULL on failure
10004 static const struct ipr_chip_t *
10005 ipr_get_chip_info(const struct pci_device_id *dev_id)
10009 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
10010 if (ipr_chip[i].vendor == dev_id->vendor &&
10011 ipr_chip[i].device == dev_id->device)
10012 return &ipr_chip[i];
10017 * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
10018 * during probe time
10019 * @ioa_cfg: ioa config struct
10024 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg)
10026 struct pci_dev *pdev = ioa_cfg->pdev;
10028 if (pci_channel_offline(pdev)) {
10029 wait_event_timeout(ioa_cfg->eeh_wait_q,
10030 !pci_channel_offline(pdev),
10031 IPR_PCI_ERROR_RECOVERY_TIMEOUT);
10032 pci_restore_state(pdev);
10036 static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg)
10038 int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1;
10040 for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) {
10041 snprintf(ioa_cfg->vectors_info[vec_idx].desc, n,
10042 "host%d-%d", ioa_cfg->host->host_no, vec_idx);
10043 ioa_cfg->vectors_info[vec_idx].
10044 desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0;
10048 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg,
10049 struct pci_dev *pdev)
10053 for (i = 1; i < ioa_cfg->nvectors; i++) {
10054 rc = request_irq(pci_irq_vector(pdev, i),
10057 ioa_cfg->vectors_info[i].desc,
10058 &ioa_cfg->hrrq[i]);
10061 free_irq(pci_irq_vector(pdev, i),
10062 &ioa_cfg->hrrq[i]);
10070 * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
10071 * @devp: PCI device struct
10074 * Description: Simply set the msi_received flag to 1 indicating that
10075 * Message Signaled Interrupts are supported.
10078 * 0 on success / non-zero on failure
10080 static irqreturn_t ipr_test_intr(int irq, void *devp)
10082 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
10083 unsigned long lock_flags = 0;
10085 dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq);
10086 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10088 ioa_cfg->msi_received = 1;
10089 wake_up(&ioa_cfg->msi_wait_q);
10091 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10092 return IRQ_HANDLED;
10096 * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
10097 * @ioa_cfg: ioa config struct
10098 * @pdev: PCI device struct
10100 * Description: This routine sets up and initiates a test interrupt to determine
10101 * if the interrupt is received via the ipr_test_intr() service routine.
10102 * If the tests fails, the driver will fall back to LSI.
10105 * 0 on success / non-zero on failure
10107 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
10110 unsigned long lock_flags = 0;
10111 int irq = pci_irq_vector(pdev, 0);
10115 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10116 init_waitqueue_head(&ioa_cfg->msi_wait_q);
10117 ioa_cfg->msi_received = 0;
10118 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10119 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
10120 readl(ioa_cfg->regs.sense_interrupt_mask_reg);
10121 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10123 rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
10125 dev_err(&pdev->dev, "Can not assign irq %d\n", irq);
10127 } else if (ipr_debug)
10128 dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
10130 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
10131 readl(ioa_cfg->regs.sense_interrupt_reg);
10132 wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
10133 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10134 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10136 if (!ioa_cfg->msi_received) {
10137 /* MSI test failed */
10138 dev_info(&pdev->dev, "MSI test failed. Falling back to LSI.\n");
10140 } else if (ipr_debug)
10141 dev_info(&pdev->dev, "MSI test succeeded.\n");
10143 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10145 free_irq(irq, ioa_cfg);
10152 /* ipr_probe_ioa - Allocates memory and does first stage of initialization
10153 * @pdev: PCI device struct
10154 * @dev_id: PCI device id struct
10157 * 0 on success / non-zero on failure
10159 static int ipr_probe_ioa(struct pci_dev *pdev,
10160 const struct pci_device_id *dev_id)
10162 struct ipr_ioa_cfg *ioa_cfg;
10163 struct Scsi_Host *host;
10164 unsigned long ipr_regs_pci;
10165 void __iomem *ipr_regs;
10166 int rc = PCIBIOS_SUCCESSFUL;
10167 volatile u32 mask, uproc, interrupts;
10168 unsigned long lock_flags, driver_lock_flags;
10169 unsigned int irq_flag;
10173 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
10174 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
10177 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
10182 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
10183 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
10184 ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops);
10186 ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
10188 if (!ioa_cfg->ipr_chip) {
10189 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
10190 dev_id->vendor, dev_id->device);
10191 goto out_scsi_host_put;
10194 /* set SIS 32 or SIS 64 */
10195 ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
10196 ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
10197 ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr;
10198 ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds;
10200 if (ipr_transop_timeout)
10201 ioa_cfg->transop_timeout = ipr_transop_timeout;
10202 else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
10203 ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
10205 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
10207 ioa_cfg->revid = pdev->revision;
10209 ipr_init_ioa_cfg(ioa_cfg, host, pdev);
10211 ipr_regs_pci = pci_resource_start(pdev, 0);
10213 rc = pci_request_regions(pdev, IPR_NAME);
10215 dev_err(&pdev->dev,
10216 "Couldn't register memory range of registers\n");
10217 goto out_scsi_host_put;
10220 rc = pci_enable_device(pdev);
10222 if (rc || pci_channel_offline(pdev)) {
10223 if (pci_channel_offline(pdev)) {
10224 ipr_wait_for_pci_err_recovery(ioa_cfg);
10225 rc = pci_enable_device(pdev);
10229 dev_err(&pdev->dev, "Cannot enable adapter\n");
10230 ipr_wait_for_pci_err_recovery(ioa_cfg);
10231 goto out_release_regions;
10235 ipr_regs = pci_ioremap_bar(pdev, 0);
10238 dev_err(&pdev->dev,
10239 "Couldn't map memory range of registers\n");
10244 ioa_cfg->hdw_dma_regs = ipr_regs;
10245 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
10246 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
10248 ipr_init_regs(ioa_cfg);
10250 if (ioa_cfg->sis64) {
10251 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
10253 dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
10254 rc = dma_set_mask_and_coherent(&pdev->dev,
10258 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
10261 dev_err(&pdev->dev, "Failed to set DMA mask\n");
10262 goto cleanup_nomem;
10265 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
10266 ioa_cfg->chip_cfg->cache_line_size);
10268 if (rc != PCIBIOS_SUCCESSFUL) {
10269 dev_err(&pdev->dev, "Write of cache line size failed\n");
10270 ipr_wait_for_pci_err_recovery(ioa_cfg);
10272 goto cleanup_nomem;
10275 /* Issue MMIO read to ensure card is not in EEH */
10276 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
10277 ipr_wait_for_pci_err_recovery(ioa_cfg);
10279 if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) {
10280 dev_err(&pdev->dev, "The max number of MSIX is %d\n",
10281 IPR_MAX_MSIX_VECTORS);
10282 ipr_number_of_msix = IPR_MAX_MSIX_VECTORS;
10285 irq_flag = PCI_IRQ_LEGACY;
10286 if (ioa_cfg->ipr_chip->has_msi)
10287 irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX;
10288 rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag);
10290 ipr_wait_for_pci_err_recovery(ioa_cfg);
10291 goto cleanup_nomem;
10293 ioa_cfg->nvectors = rc;
10295 if (!pdev->msi_enabled && !pdev->msix_enabled)
10296 ioa_cfg->clear_isr = 1;
10298 pci_set_master(pdev);
10300 if (pci_channel_offline(pdev)) {
10301 ipr_wait_for_pci_err_recovery(ioa_cfg);
10302 pci_set_master(pdev);
10303 if (pci_channel_offline(pdev)) {
10305 goto out_msi_disable;
10309 if (pdev->msi_enabled || pdev->msix_enabled) {
10310 rc = ipr_test_msi(ioa_cfg, pdev);
10313 dev_info(&pdev->dev,
10314 "Request for %d MSI%ss succeeded.", ioa_cfg->nvectors,
10315 pdev->msix_enabled ? "-X" : "");
10318 ipr_wait_for_pci_err_recovery(ioa_cfg);
10319 pci_free_irq_vectors(pdev);
10321 ioa_cfg->nvectors = 1;
10322 ioa_cfg->clear_isr = 1;
10325 goto out_msi_disable;
10329 ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors,
10330 (unsigned int)num_online_cpus(),
10331 (unsigned int)IPR_MAX_HRRQ_NUM);
10333 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
10334 goto out_msi_disable;
10336 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
10337 goto out_msi_disable;
10339 rc = ipr_alloc_mem(ioa_cfg);
10341 dev_err(&pdev->dev,
10342 "Couldn't allocate enough memory for device driver!\n");
10343 goto out_msi_disable;
10346 /* Save away PCI config space for use following IOA reset */
10347 rc = pci_save_state(pdev);
10349 if (rc != PCIBIOS_SUCCESSFUL) {
10350 dev_err(&pdev->dev, "Failed to save PCI config space\n");
10352 goto cleanup_nolog;
10356 * If HRRQ updated interrupt is not masked, or reset alert is set,
10357 * the card is in an unknown state and needs a hard reset
10359 mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
10360 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
10361 uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
10362 if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
10363 ioa_cfg->needs_hard_reset = 1;
10364 if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices)
10365 ioa_cfg->needs_hard_reset = 1;
10366 if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
10367 ioa_cfg->ioa_unit_checked = 1;
10369 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10370 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10371 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10373 if (pdev->msi_enabled || pdev->msix_enabled) {
10374 name_msi_vectors(ioa_cfg);
10375 rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0,
10376 ioa_cfg->vectors_info[0].desc,
10377 &ioa_cfg->hrrq[0]);
10379 rc = ipr_request_other_msi_irqs(ioa_cfg, pdev);
10381 rc = request_irq(pdev->irq, ipr_isr,
10383 IPR_NAME, &ioa_cfg->hrrq[0]);
10386 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
10388 goto cleanup_nolog;
10391 if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
10392 (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
10393 ioa_cfg->needs_warm_reset = 1;
10394 ioa_cfg->reset = ipr_reset_slot_reset;
10396 ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d",
10397 WQ_MEM_RECLAIM, host->host_no);
10399 if (!ioa_cfg->reset_work_q) {
10400 dev_err(&pdev->dev, "Couldn't register reset workqueue\n");
10405 ioa_cfg->reset = ipr_reset_start_bist;
10407 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10408 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
10409 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10416 ipr_free_irqs(ioa_cfg);
10418 ipr_free_mem(ioa_cfg);
10420 ipr_wait_for_pci_err_recovery(ioa_cfg);
10421 pci_free_irq_vectors(pdev);
10425 pci_disable_device(pdev);
10426 out_release_regions:
10427 pci_release_regions(pdev);
10429 scsi_host_put(host);
10434 * ipr_initiate_ioa_bringdown - Bring down an adapter
10435 * @ioa_cfg: ioa config struct
10436 * @shutdown_type: shutdown type
10438 * Description: This function will initiate bringing down the adapter.
10439 * This consists of issuing an IOA shutdown to the adapter
10440 * to flush the cache, and running BIST.
10441 * If the caller needs to wait on the completion of the reset,
10442 * the caller must sleep on the reset_wait_q.
10447 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
10448 enum ipr_shutdown_type shutdown_type)
10451 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
10452 ioa_cfg->sdt_state = ABORT_DUMP;
10453 ioa_cfg->reset_retries = 0;
10454 ioa_cfg->in_ioa_bringdown = 1;
10455 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
10460 * __ipr_remove - Remove a single adapter
10461 * @pdev: pci device struct
10463 * Adapter hot plug remove entry point.
10468 static void __ipr_remove(struct pci_dev *pdev)
10470 unsigned long host_lock_flags = 0;
10471 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10473 unsigned long driver_lock_flags;
10476 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10477 while (ioa_cfg->in_reset_reload) {
10478 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10479 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10480 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10483 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
10484 spin_lock(&ioa_cfg->hrrq[i]._lock);
10485 ioa_cfg->hrrq[i].removing_ioa = 1;
10486 spin_unlock(&ioa_cfg->hrrq[i]._lock);
10489 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
10491 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10492 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10493 flush_work(&ioa_cfg->work_q);
10494 if (ioa_cfg->reset_work_q)
10495 flush_workqueue(ioa_cfg->reset_work_q);
10496 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
10497 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10499 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10500 list_del(&ioa_cfg->queue);
10501 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10503 if (ioa_cfg->sdt_state == ABORT_DUMP)
10504 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
10505 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10507 ipr_free_all_resources(ioa_cfg);
10513 * ipr_remove - IOA hot plug remove entry point
10514 * @pdev: pci device struct
10516 * Adapter hot plug remove entry point.
10521 static void ipr_remove(struct pci_dev *pdev)
10523 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10527 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10529 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10531 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10532 &ipr_ioa_async_err_log);
10533 scsi_remove_host(ioa_cfg->host);
10535 __ipr_remove(pdev);
10541 * ipr_probe - Adapter hot plug add entry point
10542 * @pdev: pci device struct
10543 * @dev_id: pci device ID
10546 * 0 on success / non-zero on failure
10548 static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
10550 struct ipr_ioa_cfg *ioa_cfg;
10551 unsigned long flags;
10554 rc = ipr_probe_ioa(pdev, dev_id);
10559 ioa_cfg = pci_get_drvdata(pdev);
10560 ipr_probe_ioa_part2(ioa_cfg);
10562 rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
10565 __ipr_remove(pdev);
10569 rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
10573 scsi_remove_host(ioa_cfg->host);
10574 __ipr_remove(pdev);
10578 rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj,
10579 &ipr_ioa_async_err_log);
10582 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10584 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10586 scsi_remove_host(ioa_cfg->host);
10587 __ipr_remove(pdev);
10591 rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
10595 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10596 &ipr_ioa_async_err_log);
10597 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10599 scsi_remove_host(ioa_cfg->host);
10600 __ipr_remove(pdev);
10603 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10604 ioa_cfg->scan_enabled = 1;
10605 schedule_work(&ioa_cfg->work_q);
10606 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10608 ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight;
10610 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10611 for (i = 1; i < ioa_cfg->hrrq_num; i++) {
10612 irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
10613 ioa_cfg->iopoll_weight, ipr_iopoll);
10617 scsi_scan_host(ioa_cfg->host);
10623 * ipr_shutdown - Shutdown handler.
10624 * @pdev: pci device struct
10626 * This function is invoked upon system shutdown/reboot. It will issue
10627 * an adapter shutdown to the adapter to flush the write cache.
10632 static void ipr_shutdown(struct pci_dev *pdev)
10634 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10635 unsigned long lock_flags = 0;
10636 enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL;
10639 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10640 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10641 ioa_cfg->iopoll_weight = 0;
10642 for (i = 1; i < ioa_cfg->hrrq_num; i++)
10643 irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
10646 while (ioa_cfg->in_reset_reload) {
10647 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10648 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10649 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10652 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64)
10653 shutdown_type = IPR_SHUTDOWN_QUIESCE;
10655 ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type);
10656 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10657 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10658 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) {
10659 ipr_free_irqs(ioa_cfg);
10660 pci_disable_device(ioa_cfg->pdev);
10664 static struct pci_device_id ipr_pci_table[] = {
10665 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10666 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
10667 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10668 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
10669 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10670 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
10671 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10672 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
10673 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10674 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
10675 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10676 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
10677 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10678 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
10679 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10680 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
10681 IPR_USE_LONG_TRANSOP_TIMEOUT },
10682 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10683 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10684 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10685 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10686 IPR_USE_LONG_TRANSOP_TIMEOUT },
10687 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10688 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10689 IPR_USE_LONG_TRANSOP_TIMEOUT },
10690 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10691 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10692 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10693 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10694 IPR_USE_LONG_TRANSOP_TIMEOUT},
10695 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10696 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10697 IPR_USE_LONG_TRANSOP_TIMEOUT },
10698 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10699 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
10700 IPR_USE_LONG_TRANSOP_TIMEOUT },
10701 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10702 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
10703 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10704 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 },
10705 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10706 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
10707 IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
10708 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
10709 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
10710 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10711 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
10712 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10713 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
10714 IPR_USE_LONG_TRANSOP_TIMEOUT },
10715 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10716 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
10717 IPR_USE_LONG_TRANSOP_TIMEOUT },
10718 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10719 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
10720 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10721 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
10722 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10723 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
10724 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10725 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 },
10726 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10727 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 },
10728 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10729 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 },
10730 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10731 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
10732 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10733 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
10734 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10735 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
10736 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10737 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 },
10738 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10739 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
10740 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10741 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 },
10742 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10743 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 },
10744 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10745 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 },
10746 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10747 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 },
10748 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10749 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 },
10750 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10751 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 },
10752 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10753 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 },
10754 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10755 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 },
10756 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10757 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 },
10758 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10759 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 },
10760 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10761 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 },
10762 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10763 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 },
10764 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10765 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 },
10766 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10767 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 },
10768 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10769 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 },
10770 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10771 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 },
10772 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10773 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 },
10776 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
10778 static const struct pci_error_handlers ipr_err_handler = {
10779 .error_detected = ipr_pci_error_detected,
10780 .mmio_enabled = ipr_pci_mmio_enabled,
10781 .slot_reset = ipr_pci_slot_reset,
10784 static struct pci_driver ipr_driver = {
10786 .id_table = ipr_pci_table,
10787 .probe = ipr_probe,
10788 .remove = ipr_remove,
10789 .shutdown = ipr_shutdown,
10790 .err_handler = &ipr_err_handler,
10794 * ipr_halt_done - Shutdown prepare completion
10795 * @ipr_cmd: ipr command struct
10800 static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
10802 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
10806 * ipr_halt - Issue shutdown prepare to all adapters
10807 * @nb: Notifier block
10808 * @event: Notifier event
10809 * @buf: Notifier data (unused)
10812 * NOTIFY_OK on success / NOTIFY_DONE on failure
10814 static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
10816 struct ipr_cmnd *ipr_cmd;
10817 struct ipr_ioa_cfg *ioa_cfg;
10818 unsigned long flags = 0, driver_lock_flags;
10820 if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
10821 return NOTIFY_DONE;
10823 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10825 list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
10826 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10827 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
10828 (ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) {
10829 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10833 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
10834 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
10835 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
10836 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
10837 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
10839 ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
10840 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10842 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10847 static struct notifier_block ipr_notifier = {
10852 * ipr_init - Module entry point
10855 * 0 on success / negative value on failure
10857 static int __init ipr_init(void)
10861 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10862 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
10864 register_reboot_notifier(&ipr_notifier);
10865 rc = pci_register_driver(&ipr_driver);
10867 unregister_reboot_notifier(&ipr_notifier);
10875 * ipr_exit - Module unload
10877 * Module unload entry point.
10882 static void __exit ipr_exit(void)
10884 unregister_reboot_notifier(&ipr_notifier);
10885 pci_unregister_driver(&ipr_driver);
10888 module_init(ipr_init);
10889 module_exit(ipr_exit);