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
677 static void ipr_init_ipr_cmnd(struct ipr_cmnd
*ipr_cmd
,
678 void (*fast_done
) (struct ipr_cmnd
*))
680 ipr_reinit_ipr_cmnd(ipr_cmd
);
681 ipr_cmd
->u
.scratch
= 0;
682 ipr_cmd
->sibling
= NULL
;
683 ipr_cmd
->eh_comp
= NULL
;
684 ipr_cmd
->fast_done
= fast_done
;
685 timer_setup(&ipr_cmd
->timer
, NULL
, 0);
689 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
690 * @ioa_cfg: ioa config struct
693 * pointer to ipr command struct
696 struct ipr_cmnd
*__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue
*hrrq
)
698 struct ipr_cmnd
*ipr_cmd
= NULL
;
700 if (likely(!list_empty(&hrrq
->hrrq_free_q
))) {
701 ipr_cmd
= list_entry(hrrq
->hrrq_free_q
.next
,
702 struct ipr_cmnd
, queue
);
703 list_del(&ipr_cmd
->queue
);
711 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
712 * @ioa_cfg: ioa config struct
715 * pointer to ipr command struct
718 struct ipr_cmnd
*ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg
*ioa_cfg
)
720 struct ipr_cmnd
*ipr_cmd
=
721 __ipr_get_free_ipr_cmnd(&ioa_cfg
->hrrq
[IPR_INIT_HRRQ
]);
722 ipr_init_ipr_cmnd(ipr_cmd
, ipr_lock_and_done
);
727 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
728 * @ioa_cfg: ioa config struct
729 * @clr_ints: interrupts to clear
731 * This function masks all interrupts on the adapter, then clears the
732 * interrupts specified in the mask
737 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg
*ioa_cfg
,
740 volatile u32 int_reg
;
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 int_reg
= 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
);
869 scsi_cmd
->scsi_done(scsi_cmd
);
870 if (ipr_cmd
->eh_comp
)
871 complete(ipr_cmd
->eh_comp
);
872 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
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
+= snprintf(p
, buffer
+ len
- p
, "%02X", res_path
[0]);
1303 for (i
= 1; res_path
[i
] != 0xff && ((i
* 3) < len
); i
++)
1304 p
+= snprintf(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
+= snprintf(p
, buffer
+ len
- p
, "%d/", ioa_cfg
->host
->host_no
);
1326 __ipr_format_res_path(res_path
, p
, len
- (buffer
- p
));
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
1394 * @cfgtew: config table entry wrapper struct
1399 static void ipr_clear_res_target(struct ipr_resource_entry
*res
)
1401 struct ipr_resource_entry
*gscsi_res
= NULL
;
1402 struct ipr_ioa_cfg
*ioa_cfg
= res
->ioa_cfg
;
1404 if (!ioa_cfg
->sis64
)
1407 if (res
->bus
== IPR_ARRAY_VIRTUAL_BUS
)
1408 clear_bit(res
->target
, ioa_cfg
->array_ids
);
1409 else if (res
->bus
== IPR_VSET_VIRTUAL_BUS
)
1410 clear_bit(res
->target
, ioa_cfg
->vset_ids
);
1411 else if (res
->bus
== 0 && res
->type
== IPR_RES_TYPE_GENERIC_SCSI
) {
1412 list_for_each_entry(gscsi_res
, &ioa_cfg
->used_res_q
, queue
)
1413 if (gscsi_res
->dev_id
== res
->dev_id
&& gscsi_res
!= res
)
1415 clear_bit(res
->target
, ioa_cfg
->target_ids
);
1417 } else if (res
->bus
== 0)
1418 clear_bit(res
->target
, ioa_cfg
->target_ids
);
1422 * ipr_handle_config_change - Handle a config change from the adapter
1423 * @ioa_cfg: ioa config struct
1429 static void ipr_handle_config_change(struct ipr_ioa_cfg
*ioa_cfg
,
1430 struct ipr_hostrcb
*hostrcb
)
1432 struct ipr_resource_entry
*res
= NULL
;
1433 struct ipr_config_table_entry_wrapper cfgtew
;
1434 __be32 cc_res_handle
;
1438 if (ioa_cfg
->sis64
) {
1439 cfgtew
.u
.cfgte64
= &hostrcb
->hcam
.u
.ccn
.u
.cfgte64
;
1440 cc_res_handle
= cfgtew
.u
.cfgte64
->res_handle
;
1442 cfgtew
.u
.cfgte
= &hostrcb
->hcam
.u
.ccn
.u
.cfgte
;
1443 cc_res_handle
= cfgtew
.u
.cfgte
->res_handle
;
1446 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
1447 if (res
->res_handle
== cc_res_handle
) {
1454 if (list_empty(&ioa_cfg
->free_res_q
)) {
1455 ipr_send_hcam(ioa_cfg
,
1456 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
,
1461 res
= list_entry(ioa_cfg
->free_res_q
.next
,
1462 struct ipr_resource_entry
, queue
);
1464 list_del(&res
->queue
);
1465 ipr_init_res_entry(res
, &cfgtew
);
1466 list_add_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
1469 ipr_update_res_entry(res
, &cfgtew
);
1471 if (hostrcb
->hcam
.notify_type
== IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY
) {
1473 res
->del_from_ml
= 1;
1474 res
->res_handle
= IPR_INVALID_RES_HANDLE
;
1475 schedule_work(&ioa_cfg
->work_q
);
1477 ipr_clear_res_target(res
);
1478 list_move_tail(&res
->queue
, &ioa_cfg
->free_res_q
);
1480 } else if (!res
->sdev
|| res
->del_from_ml
) {
1482 schedule_work(&ioa_cfg
->work_q
);
1485 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
, hostrcb
);
1489 * ipr_process_ccn - Op done function for a CCN.
1490 * @ipr_cmd: ipr command struct
1492 * This function is the op done function for a configuration
1493 * change notification host controlled async from the adapter.
1498 static void ipr_process_ccn(struct ipr_cmnd
*ipr_cmd
)
1500 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
1501 struct ipr_hostrcb
*hostrcb
= ipr_cmd
->u
.hostrcb
;
1502 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
1504 list_del_init(&hostrcb
->queue
);
1505 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
1508 if (ioasc
!= IPR_IOASC_IOA_WAS_RESET
&&
1509 ioasc
!= IPR_IOASC_ABORTED_CMD_TERM_BY_HOST
)
1510 dev_err(&ioa_cfg
->pdev
->dev
,
1511 "Host RCB failed with IOASC: 0x%08X\n", ioasc
);
1513 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
, hostrcb
);
1515 ipr_handle_config_change(ioa_cfg
, hostrcb
);
1520 * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1521 * @i: index into buffer
1522 * @buf: string to modify
1524 * This function will strip all trailing whitespace, pad the end
1525 * of the string with a single space, and NULL terminate the string.
1528 * new length of string
1530 static int strip_and_pad_whitespace(int i
, char *buf
)
1532 while (i
&& buf
[i
] == ' ')
1540 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1541 * @prefix: string to print at start of printk
1542 * @hostrcb: hostrcb pointer
1543 * @vpd: vendor/product id/sn struct
1548 static void ipr_log_vpd_compact(char *prefix
, struct ipr_hostrcb
*hostrcb
,
1549 struct ipr_vpd
*vpd
)
1551 char buffer
[IPR_VENDOR_ID_LEN
+ IPR_PROD_ID_LEN
+ IPR_SERIAL_NUM_LEN
+ 3];
1554 memcpy(buffer
, vpd
->vpids
.vendor_id
, IPR_VENDOR_ID_LEN
);
1555 i
= strip_and_pad_whitespace(IPR_VENDOR_ID_LEN
- 1, buffer
);
1557 memcpy(&buffer
[i
], vpd
->vpids
.product_id
, IPR_PROD_ID_LEN
);
1558 i
= strip_and_pad_whitespace(i
+ IPR_PROD_ID_LEN
- 1, buffer
);
1560 memcpy(&buffer
[i
], vpd
->sn
, IPR_SERIAL_NUM_LEN
);
1561 buffer
[IPR_SERIAL_NUM_LEN
+ i
] = '\0';
1563 ipr_hcam_err(hostrcb
, "%s VPID/SN: %s\n", prefix
, buffer
);
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 * @ipr_cmd: 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 * @ipr_cmd: 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
= container_of(kobj
, struct device
, 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
3490 * number of bytes printed to buffer
3492 static ssize_t
ipr_show_fw_version(struct device
*dev
,
3493 struct device_attribute
*attr
, char *buf
)
3495 struct Scsi_Host
*shost
= class_to_shost(dev
);
3496 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3497 struct ipr_inquiry_page3
*ucode_vpd
= &ioa_cfg
->vpd_cbs
->page3_data
;
3498 unsigned long lock_flags
= 0;
3501 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3502 len
= snprintf(buf
, PAGE_SIZE
, "%02X%02X%02X%02X\n",
3503 ucode_vpd
->major_release
, ucode_vpd
->card_type
,
3504 ucode_vpd
->minor_release
[0],
3505 ucode_vpd
->minor_release
[1]);
3506 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3510 static struct device_attribute ipr_fw_version_attr
= {
3512 .name
= "fw_version",
3515 .show
= ipr_show_fw_version
,
3519 * ipr_show_log_level - Show the adapter's error logging level
3520 * @dev: class device struct
3524 * number of bytes printed to buffer
3526 static ssize_t
ipr_show_log_level(struct device
*dev
,
3527 struct device_attribute
*attr
, char *buf
)
3529 struct Scsi_Host
*shost
= class_to_shost(dev
);
3530 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3531 unsigned long lock_flags
= 0;
3534 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3535 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->log_level
);
3536 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3541 * ipr_store_log_level - Change the adapter's error logging level
3542 * @dev: class device struct
3546 * number of bytes printed to buffer
3548 static ssize_t
ipr_store_log_level(struct device
*dev
,
3549 struct device_attribute
*attr
,
3550 const char *buf
, size_t count
)
3552 struct Scsi_Host
*shost
= class_to_shost(dev
);
3553 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3554 unsigned long lock_flags
= 0;
3556 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3557 ioa_cfg
->log_level
= simple_strtoul(buf
, NULL
, 10);
3558 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3562 static struct device_attribute ipr_log_level_attr
= {
3564 .name
= "log_level",
3565 .mode
= S_IRUGO
| S_IWUSR
,
3567 .show
= ipr_show_log_level
,
3568 .store
= ipr_store_log_level
3572 * ipr_store_diagnostics - IOA Diagnostics interface
3573 * @dev: device struct
3575 * @count: buffer size
3577 * This function will reset the adapter and wait a reasonable
3578 * amount of time for any errors that the adapter might log.
3581 * count on success / other on failure
3583 static ssize_t
ipr_store_diagnostics(struct device
*dev
,
3584 struct device_attribute
*attr
,
3585 const char *buf
, size_t count
)
3587 struct Scsi_Host
*shost
= class_to_shost(dev
);
3588 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3589 unsigned long lock_flags
= 0;
3592 if (!capable(CAP_SYS_ADMIN
))
3595 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3596 while (ioa_cfg
->in_reset_reload
) {
3597 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3598 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3599 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3602 ioa_cfg
->errors_logged
= 0;
3603 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
3605 if (ioa_cfg
->in_reset_reload
) {
3606 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3607 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3609 /* Wait for a second for any errors to be logged */
3612 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3616 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3617 if (ioa_cfg
->in_reset_reload
|| ioa_cfg
->errors_logged
)
3619 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3624 static struct device_attribute ipr_diagnostics_attr
= {
3626 .name
= "run_diagnostics",
3629 .store
= ipr_store_diagnostics
3633 * ipr_show_adapter_state - Show the adapter's state
3634 * @class_dev: device struct
3638 * number of bytes printed to buffer
3640 static ssize_t
ipr_show_adapter_state(struct device
*dev
,
3641 struct device_attribute
*attr
, char *buf
)
3643 struct Scsi_Host
*shost
= class_to_shost(dev
);
3644 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3645 unsigned long lock_flags
= 0;
3648 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3649 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
3650 len
= snprintf(buf
, PAGE_SIZE
, "offline\n");
3652 len
= snprintf(buf
, PAGE_SIZE
, "online\n");
3653 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3658 * ipr_store_adapter_state - Change adapter state
3659 * @dev: device struct
3661 * @count: buffer size
3663 * This function will change the adapter's state.
3666 * count on success / other on failure
3668 static ssize_t
ipr_store_adapter_state(struct device
*dev
,
3669 struct device_attribute
*attr
,
3670 const char *buf
, size_t count
)
3672 struct Scsi_Host
*shost
= class_to_shost(dev
);
3673 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3674 unsigned long lock_flags
;
3675 int result
= count
, i
;
3677 if (!capable(CAP_SYS_ADMIN
))
3680 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3681 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
&&
3682 !strncmp(buf
, "online", 6)) {
3683 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
3684 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
3685 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 0;
3686 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
3689 ioa_cfg
->reset_retries
= 0;
3690 ioa_cfg
->in_ioa_bringdown
= 0;
3691 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
3693 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3694 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3699 static struct device_attribute ipr_ioa_state_attr
= {
3701 .name
= "online_state",
3702 .mode
= S_IRUGO
| S_IWUSR
,
3704 .show
= ipr_show_adapter_state
,
3705 .store
= ipr_store_adapter_state
3709 * ipr_store_reset_adapter - Reset the adapter
3710 * @dev: device struct
3712 * @count: buffer size
3714 * This function will reset the adapter.
3717 * count on success / other on failure
3719 static ssize_t
ipr_store_reset_adapter(struct device
*dev
,
3720 struct device_attribute
*attr
,
3721 const char *buf
, size_t count
)
3723 struct Scsi_Host
*shost
= class_to_shost(dev
);
3724 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3725 unsigned long lock_flags
;
3728 if (!capable(CAP_SYS_ADMIN
))
3731 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3732 if (!ioa_cfg
->in_reset_reload
)
3733 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
3734 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3735 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3740 static struct device_attribute ipr_ioa_reset_attr
= {
3742 .name
= "reset_host",
3745 .store
= ipr_store_reset_adapter
3748 static int ipr_iopoll(struct irq_poll
*iop
, int budget
);
3750 * ipr_show_iopoll_weight - Show ipr polling mode
3751 * @dev: class device struct
3755 * number of bytes printed to buffer
3757 static ssize_t
ipr_show_iopoll_weight(struct device
*dev
,
3758 struct device_attribute
*attr
, char *buf
)
3760 struct Scsi_Host
*shost
= class_to_shost(dev
);
3761 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3762 unsigned long lock_flags
= 0;
3765 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
3766 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->iopoll_weight
);
3767 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
3773 * ipr_store_iopoll_weight - Change the adapter's polling mode
3774 * @dev: class device struct
3778 * number of bytes printed to buffer
3780 static ssize_t
ipr_store_iopoll_weight(struct device
*dev
,
3781 struct device_attribute
*attr
,
3782 const char *buf
, size_t count
)
3784 struct Scsi_Host
*shost
= class_to_shost(dev
);
3785 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3786 unsigned long user_iopoll_weight
;
3787 unsigned long lock_flags
= 0;
3790 if (!ioa_cfg
->sis64
) {
3791 dev_info(&ioa_cfg
->pdev
->dev
, "irq_poll not supported on this adapter\n");
3794 if (kstrtoul(buf
, 10, &user_iopoll_weight
))
3797 if (user_iopoll_weight
> 256) {
3798 dev_info(&ioa_cfg
->pdev
->dev
, "Invalid irq_poll weight. It must be less than 256\n");
3802 if (user_iopoll_weight
== ioa_cfg
->iopoll_weight
) {
3803 dev_info(&ioa_cfg
->pdev
->dev
, "Current irq_poll weight has the same weight\n");
3807 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
3808 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++)
3809 irq_poll_disable(&ioa_cfg
->hrrq
[i
].iopoll
);
3812 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
3813 ioa_cfg
->iopoll_weight
= user_iopoll_weight
;
3814 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
3815 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++) {
3816 irq_poll_init(&ioa_cfg
->hrrq
[i
].iopoll
,
3817 ioa_cfg
->iopoll_weight
, ipr_iopoll
);
3820 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
3825 static struct device_attribute ipr_iopoll_weight_attr
= {
3827 .name
= "iopoll_weight",
3828 .mode
= S_IRUGO
| S_IWUSR
,
3830 .show
= ipr_show_iopoll_weight
,
3831 .store
= ipr_store_iopoll_weight
3835 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3836 * @buf_len: buffer length
3838 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3839 * list to use for microcode download
3842 * pointer to sglist / NULL on failure
3844 static struct ipr_sglist
*ipr_alloc_ucode_buffer(int buf_len
)
3847 struct ipr_sglist
*sglist
;
3849 /* Get the minimum size per scatter/gather element */
3850 sg_size
= buf_len
/ (IPR_MAX_SGLIST
- 1);
3852 /* Get the actual size per element */
3853 order
= get_order(sg_size
);
3855 /* Allocate a scatter/gather list for the DMA */
3856 sglist
= kzalloc(sizeof(struct ipr_sglist
), GFP_KERNEL
);
3857 if (sglist
== NULL
) {
3861 sglist
->order
= order
;
3862 sglist
->scatterlist
= sgl_alloc_order(buf_len
, order
, false, GFP_KERNEL
,
3864 if (!sglist
->scatterlist
) {
3873 * ipr_free_ucode_buffer - Frees a microcode download buffer
3874 * @p_dnld: scatter/gather list pointer
3876 * Free a DMA'able ucode download buffer previously allocated with
3877 * ipr_alloc_ucode_buffer
3882 static void ipr_free_ucode_buffer(struct ipr_sglist
*sglist
)
3884 sgl_free_order(sglist
->scatterlist
, sglist
->order
);
3889 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3890 * @sglist: scatter/gather list pointer
3891 * @buffer: buffer pointer
3892 * @len: buffer length
3894 * Copy a microcode image from a user buffer into a buffer allocated by
3895 * ipr_alloc_ucode_buffer
3898 * 0 on success / other on failure
3900 static int ipr_copy_ucode_buffer(struct ipr_sglist
*sglist
,
3901 u8
*buffer
, u32 len
)
3903 int bsize_elem
, i
, result
= 0;
3904 struct scatterlist
*sg
;
3907 /* Determine the actual number of bytes per element */
3908 bsize_elem
= PAGE_SIZE
* (1 << sglist
->order
);
3910 sg
= sglist
->scatterlist
;
3912 for (i
= 0; i
< (len
/ bsize_elem
); i
++, sg
= sg_next(sg
),
3913 buffer
+= bsize_elem
) {
3914 struct page
*page
= sg_page(sg
);
3917 memcpy(kaddr
, buffer
, bsize_elem
);
3920 sg
->length
= bsize_elem
;
3928 if (len
% bsize_elem
) {
3929 struct page
*page
= sg_page(sg
);
3932 memcpy(kaddr
, buffer
, len
% bsize_elem
);
3935 sg
->length
= len
% bsize_elem
;
3938 sglist
->buffer_len
= len
;
3943 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3944 * @ipr_cmd: ipr command struct
3945 * @sglist: scatter/gather list
3947 * Builds a microcode download IOA data list (IOADL).
3950 static void ipr_build_ucode_ioadl64(struct ipr_cmnd
*ipr_cmd
,
3951 struct ipr_sglist
*sglist
)
3953 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
3954 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ioadl64
;
3955 struct scatterlist
*scatterlist
= sglist
->scatterlist
;
3956 struct scatterlist
*sg
;
3959 ipr_cmd
->dma_use_sg
= sglist
->num_dma_sg
;
3960 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
3961 ioarcb
->data_transfer_length
= cpu_to_be32(sglist
->buffer_len
);
3964 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
3965 for_each_sg(scatterlist
, sg
, ipr_cmd
->dma_use_sg
, i
) {
3966 ioadl64
[i
].flags
= cpu_to_be32(IPR_IOADL_FLAGS_WRITE
);
3967 ioadl64
[i
].data_len
= cpu_to_be32(sg_dma_len(sg
));
3968 ioadl64
[i
].address
= cpu_to_be64(sg_dma_address(sg
));
3971 ioadl64
[i
-1].flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
3975 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3976 * @ipr_cmd: ipr command struct
3977 * @sglist: scatter/gather list
3979 * Builds a microcode download IOA data list (IOADL).
3982 static void ipr_build_ucode_ioadl(struct ipr_cmnd
*ipr_cmd
,
3983 struct ipr_sglist
*sglist
)
3985 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
3986 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
3987 struct scatterlist
*scatterlist
= sglist
->scatterlist
;
3988 struct scatterlist
*sg
;
3991 ipr_cmd
->dma_use_sg
= sglist
->num_dma_sg
;
3992 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
3993 ioarcb
->data_transfer_length
= cpu_to_be32(sglist
->buffer_len
);
3996 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
3998 for_each_sg(scatterlist
, sg
, ipr_cmd
->dma_use_sg
, i
) {
3999 ioadl
[i
].flags_and_data_len
=
4000 cpu_to_be32(IPR_IOADL_FLAGS_WRITE
| sg_dma_len(sg
));
4002 cpu_to_be32(sg_dma_address(sg
));
4005 ioadl
[i
-1].flags_and_data_len
|=
4006 cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
4010 * ipr_update_ioa_ucode - Update IOA's microcode
4011 * @ioa_cfg: ioa config struct
4012 * @sglist: scatter/gather list
4014 * Initiate an adapter reset to update the IOA's microcode
4017 * 0 on success / -EIO on failure
4019 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg
*ioa_cfg
,
4020 struct ipr_sglist
*sglist
)
4022 unsigned long lock_flags
;
4024 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4025 while (ioa_cfg
->in_reset_reload
) {
4026 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4027 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
4028 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4031 if (ioa_cfg
->ucode_sglist
) {
4032 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4033 dev_err(&ioa_cfg
->pdev
->dev
,
4034 "Microcode download already in progress\n");
4038 sglist
->num_dma_sg
= dma_map_sg(&ioa_cfg
->pdev
->dev
,
4039 sglist
->scatterlist
, sglist
->num_sg
,
4042 if (!sglist
->num_dma_sg
) {
4043 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4044 dev_err(&ioa_cfg
->pdev
->dev
,
4045 "Failed to map microcode download buffer!\n");
4049 ioa_cfg
->ucode_sglist
= sglist
;
4050 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
4051 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4052 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
4054 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4055 ioa_cfg
->ucode_sglist
= NULL
;
4056 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4061 * ipr_store_update_fw - Update the firmware on the adapter
4062 * @class_dev: device struct
4064 * @count: buffer size
4066 * This function will update the firmware on the adapter.
4069 * count on success / other on failure
4071 static ssize_t
ipr_store_update_fw(struct device
*dev
,
4072 struct device_attribute
*attr
,
4073 const char *buf
, size_t count
)
4075 struct Scsi_Host
*shost
= class_to_shost(dev
);
4076 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4077 struct ipr_ucode_image_header
*image_hdr
;
4078 const struct firmware
*fw_entry
;
4079 struct ipr_sglist
*sglist
;
4083 int result
, dnld_size
;
4085 if (!capable(CAP_SYS_ADMIN
))
4088 snprintf(fname
, sizeof(fname
), "%s", buf
);
4090 endline
= strchr(fname
, '\n');
4094 if (request_firmware(&fw_entry
, fname
, &ioa_cfg
->pdev
->dev
)) {
4095 dev_err(&ioa_cfg
->pdev
->dev
, "Firmware file %s not found\n", fname
);
4099 image_hdr
= (struct ipr_ucode_image_header
*)fw_entry
->data
;
4101 src
= (u8
*)image_hdr
+ be32_to_cpu(image_hdr
->header_length
);
4102 dnld_size
= fw_entry
->size
- be32_to_cpu(image_hdr
->header_length
);
4103 sglist
= ipr_alloc_ucode_buffer(dnld_size
);
4106 dev_err(&ioa_cfg
->pdev
->dev
, "Microcode buffer allocation failed\n");
4107 release_firmware(fw_entry
);
4111 result
= ipr_copy_ucode_buffer(sglist
, src
, dnld_size
);
4114 dev_err(&ioa_cfg
->pdev
->dev
,
4115 "Microcode buffer copy to DMA buffer failed\n");
4119 ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n");
4121 result
= ipr_update_ioa_ucode(ioa_cfg
, sglist
);
4126 ipr_free_ucode_buffer(sglist
);
4127 release_firmware(fw_entry
);
4131 static struct device_attribute ipr_update_fw_attr
= {
4133 .name
= "update_fw",
4136 .store
= ipr_store_update_fw
4140 * ipr_show_fw_type - Show the adapter's firmware type.
4141 * @dev: class device struct
4145 * number of bytes printed to buffer
4147 static ssize_t
ipr_show_fw_type(struct device
*dev
,
4148 struct device_attribute
*attr
, char *buf
)
4150 struct Scsi_Host
*shost
= class_to_shost(dev
);
4151 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4152 unsigned long lock_flags
= 0;
4155 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4156 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->sis64
);
4157 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4161 static struct device_attribute ipr_ioa_fw_type_attr
= {
4166 .show
= ipr_show_fw_type
4169 static ssize_t
ipr_read_async_err_log(struct file
*filep
, struct kobject
*kobj
,
4170 struct bin_attribute
*bin_attr
, char *buf
,
4171 loff_t off
, size_t count
)
4173 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4174 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4175 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4176 struct ipr_hostrcb
*hostrcb
;
4177 unsigned long lock_flags
= 0;
4180 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4181 hostrcb
= list_first_entry_or_null(&ioa_cfg
->hostrcb_report_q
,
4182 struct ipr_hostrcb
, queue
);
4184 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4187 ret
= memory_read_from_buffer(buf
, count
, &off
, &hostrcb
->hcam
,
4188 sizeof(hostrcb
->hcam
));
4189 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4193 static ssize_t
ipr_next_async_err_log(struct file
*filep
, struct kobject
*kobj
,
4194 struct bin_attribute
*bin_attr
, char *buf
,
4195 loff_t off
, size_t count
)
4197 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4198 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4199 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4200 struct ipr_hostrcb
*hostrcb
;
4201 unsigned long lock_flags
= 0;
4203 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4204 hostrcb
= list_first_entry_or_null(&ioa_cfg
->hostrcb_report_q
,
4205 struct ipr_hostrcb
, queue
);
4207 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4211 /* Reclaim hostrcb before exit */
4212 list_move_tail(&hostrcb
->queue
, &ioa_cfg
->hostrcb_free_q
);
4213 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4217 static struct bin_attribute ipr_ioa_async_err_log
= {
4219 .name
= "async_err_log",
4220 .mode
= S_IRUGO
| S_IWUSR
,
4223 .read
= ipr_read_async_err_log
,
4224 .write
= ipr_next_async_err_log
4227 static struct device_attribute
*ipr_ioa_attrs
[] = {
4228 &ipr_fw_version_attr
,
4229 &ipr_log_level_attr
,
4230 &ipr_diagnostics_attr
,
4231 &ipr_ioa_state_attr
,
4232 &ipr_ioa_reset_attr
,
4233 &ipr_update_fw_attr
,
4234 &ipr_ioa_fw_type_attr
,
4235 &ipr_iopoll_weight_attr
,
4239 #ifdef CONFIG_SCSI_IPR_DUMP
4241 * ipr_read_dump - Dump the adapter
4242 * @filp: open sysfs file
4243 * @kobj: kobject struct
4244 * @bin_attr: bin_attribute struct
4247 * @count: buffer size
4250 * number of bytes printed to buffer
4252 static ssize_t
ipr_read_dump(struct file
*filp
, struct kobject
*kobj
,
4253 struct bin_attribute
*bin_attr
,
4254 char *buf
, loff_t off
, size_t count
)
4256 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4257 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4258 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4259 struct ipr_dump
*dump
;
4260 unsigned long lock_flags
= 0;
4265 if (!capable(CAP_SYS_ADMIN
))
4268 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4269 dump
= ioa_cfg
->dump
;
4271 if (ioa_cfg
->sdt_state
!= DUMP_OBTAINED
|| !dump
) {
4272 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4275 kref_get(&dump
->kref
);
4276 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4278 if (off
> dump
->driver_dump
.hdr
.len
) {
4279 kref_put(&dump
->kref
, ipr_release_dump
);
4283 if (off
+ count
> dump
->driver_dump
.hdr
.len
) {
4284 count
= dump
->driver_dump
.hdr
.len
- off
;
4288 if (count
&& off
< sizeof(dump
->driver_dump
)) {
4289 if (off
+ count
> sizeof(dump
->driver_dump
))
4290 len
= sizeof(dump
->driver_dump
) - off
;
4293 src
= (u8
*)&dump
->driver_dump
+ off
;
4294 memcpy(buf
, src
, len
);
4300 off
-= sizeof(dump
->driver_dump
);
4303 sdt_end
= offsetof(struct ipr_ioa_dump
, sdt
.entry
) +
4304 (be32_to_cpu(dump
->ioa_dump
.sdt
.hdr
.num_entries_used
) *
4305 sizeof(struct ipr_sdt_entry
));
4307 sdt_end
= offsetof(struct ipr_ioa_dump
, sdt
.entry
) +
4308 (IPR_FMT2_NUM_SDT_ENTRIES
* sizeof(struct ipr_sdt_entry
));
4310 if (count
&& off
< sdt_end
) {
4311 if (off
+ count
> sdt_end
)
4312 len
= sdt_end
- off
;
4315 src
= (u8
*)&dump
->ioa_dump
+ off
;
4316 memcpy(buf
, src
, len
);
4325 if ((off
& PAGE_MASK
) != ((off
+ count
) & PAGE_MASK
))
4326 len
= PAGE_ALIGN(off
) - off
;
4329 src
= (u8
*)dump
->ioa_dump
.ioa_data
[(off
& PAGE_MASK
) >> PAGE_SHIFT
];
4330 src
+= off
& ~PAGE_MASK
;
4331 memcpy(buf
, src
, len
);
4337 kref_put(&dump
->kref
, ipr_release_dump
);
4342 * ipr_alloc_dump - Prepare for adapter dump
4343 * @ioa_cfg: ioa config struct
4346 * 0 on success / other on failure
4348 static int ipr_alloc_dump(struct ipr_ioa_cfg
*ioa_cfg
)
4350 struct ipr_dump
*dump
;
4352 unsigned long lock_flags
= 0;
4354 dump
= kzalloc(sizeof(struct ipr_dump
), GFP_KERNEL
);
4357 ipr_err("Dump memory allocation failed\n");
4362 ioa_data
= vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES
,
4365 ioa_data
= vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES
,
4369 ipr_err("Dump memory allocation failed\n");
4374 dump
->ioa_dump
.ioa_data
= ioa_data
;
4376 kref_init(&dump
->kref
);
4377 dump
->ioa_cfg
= ioa_cfg
;
4379 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4381 if (INACTIVE
!= ioa_cfg
->sdt_state
) {
4382 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4383 vfree(dump
->ioa_dump
.ioa_data
);
4388 ioa_cfg
->dump
= dump
;
4389 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
4390 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
&& !ioa_cfg
->dump_taken
) {
4391 ioa_cfg
->dump_taken
= 1;
4392 schedule_work(&ioa_cfg
->work_q
);
4394 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4400 * ipr_free_dump - Free adapter dump memory
4401 * @ioa_cfg: ioa config struct
4404 * 0 on success / other on failure
4406 static int ipr_free_dump(struct ipr_ioa_cfg
*ioa_cfg
)
4408 struct ipr_dump
*dump
;
4409 unsigned long lock_flags
= 0;
4413 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4414 dump
= ioa_cfg
->dump
;
4416 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4420 ioa_cfg
->dump
= NULL
;
4421 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4423 kref_put(&dump
->kref
, ipr_release_dump
);
4430 * ipr_write_dump - Setup dump state of adapter
4431 * @filp: open sysfs file
4432 * @kobj: kobject struct
4433 * @bin_attr: bin_attribute struct
4436 * @count: buffer size
4439 * number of bytes printed to buffer
4441 static ssize_t
ipr_write_dump(struct file
*filp
, struct kobject
*kobj
,
4442 struct bin_attribute
*bin_attr
,
4443 char *buf
, loff_t off
, size_t count
)
4445 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4446 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4447 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4450 if (!capable(CAP_SYS_ADMIN
))
4454 rc
= ipr_alloc_dump(ioa_cfg
);
4455 else if (buf
[0] == '0')
4456 rc
= ipr_free_dump(ioa_cfg
);
4466 static struct bin_attribute ipr_dump_attr
= {
4469 .mode
= S_IRUSR
| S_IWUSR
,
4472 .read
= ipr_read_dump
,
4473 .write
= ipr_write_dump
4476 static int ipr_free_dump(struct ipr_ioa_cfg
*ioa_cfg
) { return 0; };
4480 * ipr_change_queue_depth - Change the device's queue depth
4481 * @sdev: scsi device struct
4482 * @qdepth: depth to set
4483 * @reason: calling context
4488 static int ipr_change_queue_depth(struct scsi_device
*sdev
, int qdepth
)
4490 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4491 struct ipr_resource_entry
*res
;
4492 unsigned long lock_flags
= 0;
4494 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4495 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4497 if (res
&& ipr_is_gata(res
) && qdepth
> IPR_MAX_CMD_PER_ATA_LUN
)
4498 qdepth
= IPR_MAX_CMD_PER_ATA_LUN
;
4499 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4501 scsi_change_queue_depth(sdev
, qdepth
);
4502 return sdev
->queue_depth
;
4506 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4507 * @dev: device struct
4508 * @attr: device attribute structure
4512 * number of bytes printed to buffer
4514 static ssize_t
ipr_show_adapter_handle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4516 struct scsi_device
*sdev
= to_scsi_device(dev
);
4517 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4518 struct ipr_resource_entry
*res
;
4519 unsigned long lock_flags
= 0;
4520 ssize_t len
= -ENXIO
;
4522 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4523 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4525 len
= snprintf(buf
, PAGE_SIZE
, "%08X\n", res
->res_handle
);
4526 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4530 static struct device_attribute ipr_adapter_handle_attr
= {
4532 .name
= "adapter_handle",
4535 .show
= ipr_show_adapter_handle
4539 * ipr_show_resource_path - Show the resource path or the resource address for
4541 * @dev: device struct
4542 * @attr: device attribute structure
4546 * number of bytes printed to buffer
4548 static ssize_t
ipr_show_resource_path(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4550 struct scsi_device
*sdev
= to_scsi_device(dev
);
4551 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4552 struct ipr_resource_entry
*res
;
4553 unsigned long lock_flags
= 0;
4554 ssize_t len
= -ENXIO
;
4555 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
4557 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4558 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4559 if (res
&& ioa_cfg
->sis64
)
4560 len
= snprintf(buf
, PAGE_SIZE
, "%s\n",
4561 __ipr_format_res_path(res
->res_path
, buffer
,
4564 len
= snprintf(buf
, PAGE_SIZE
, "%d:%d:%d:%d\n", ioa_cfg
->host
->host_no
,
4565 res
->bus
, res
->target
, res
->lun
);
4567 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4571 static struct device_attribute ipr_resource_path_attr
= {
4573 .name
= "resource_path",
4576 .show
= ipr_show_resource_path
4580 * ipr_show_device_id - Show the device_id for this device.
4581 * @dev: device struct
4582 * @attr: device attribute structure
4586 * number of bytes printed to buffer
4588 static ssize_t
ipr_show_device_id(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4590 struct scsi_device
*sdev
= to_scsi_device(dev
);
4591 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4592 struct ipr_resource_entry
*res
;
4593 unsigned long lock_flags
= 0;
4594 ssize_t len
= -ENXIO
;
4596 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4597 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4598 if (res
&& ioa_cfg
->sis64
)
4599 len
= snprintf(buf
, PAGE_SIZE
, "0x%llx\n", be64_to_cpu(res
->dev_id
));
4601 len
= snprintf(buf
, PAGE_SIZE
, "0x%llx\n", res
->lun_wwn
);
4603 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4607 static struct device_attribute ipr_device_id_attr
= {
4609 .name
= "device_id",
4612 .show
= ipr_show_device_id
4616 * ipr_show_resource_type - Show the resource type for this device.
4617 * @dev: device struct
4618 * @attr: device attribute structure
4622 * number of bytes printed to buffer
4624 static ssize_t
ipr_show_resource_type(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4626 struct scsi_device
*sdev
= to_scsi_device(dev
);
4627 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4628 struct ipr_resource_entry
*res
;
4629 unsigned long lock_flags
= 0;
4630 ssize_t len
= -ENXIO
;
4632 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4633 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4636 len
= snprintf(buf
, PAGE_SIZE
, "%x\n", res
->type
);
4638 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4642 static struct device_attribute ipr_resource_type_attr
= {
4644 .name
= "resource_type",
4647 .show
= ipr_show_resource_type
4651 * ipr_show_raw_mode - Show the adapter's raw mode
4652 * @dev: class device struct
4656 * number of bytes printed to buffer
4658 static ssize_t
ipr_show_raw_mode(struct device
*dev
,
4659 struct device_attribute
*attr
, char *buf
)
4661 struct scsi_device
*sdev
= to_scsi_device(dev
);
4662 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4663 struct ipr_resource_entry
*res
;
4664 unsigned long lock_flags
= 0;
4667 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4668 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4670 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", res
->raw_mode
);
4673 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4678 * ipr_store_raw_mode - Change the adapter's raw mode
4679 * @dev: class device struct
4683 * number of bytes printed to buffer
4685 static ssize_t
ipr_store_raw_mode(struct device
*dev
,
4686 struct device_attribute
*attr
,
4687 const char *buf
, size_t count
)
4689 struct scsi_device
*sdev
= to_scsi_device(dev
);
4690 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4691 struct ipr_resource_entry
*res
;
4692 unsigned long lock_flags
= 0;
4695 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4696 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4698 if (ipr_is_af_dasd_device(res
)) {
4699 res
->raw_mode
= simple_strtoul(buf
, NULL
, 10);
4702 sdev_printk(KERN_INFO
, res
->sdev
, "raw mode is %s\n",
4703 res
->raw_mode
? "enabled" : "disabled");
4708 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4712 static struct device_attribute ipr_raw_mode_attr
= {
4715 .mode
= S_IRUGO
| S_IWUSR
,
4717 .show
= ipr_show_raw_mode
,
4718 .store
= ipr_store_raw_mode
4721 static struct device_attribute
*ipr_dev_attrs
[] = {
4722 &ipr_adapter_handle_attr
,
4723 &ipr_resource_path_attr
,
4724 &ipr_device_id_attr
,
4725 &ipr_resource_type_attr
,
4731 * ipr_biosparam - Return the HSC mapping
4732 * @sdev: scsi device struct
4733 * @block_device: block device pointer
4734 * @capacity: capacity of the device
4735 * @parm: Array containing returned HSC values.
4737 * This function generates the HSC parms that fdisk uses.
4738 * We want to make sure we return something that places partitions
4739 * on 4k boundaries for best performance with the IOA.
4744 static int ipr_biosparam(struct scsi_device
*sdev
,
4745 struct block_device
*block_device
,
4746 sector_t capacity
, int *parm
)
4754 cylinders
= capacity
;
4755 sector_div(cylinders
, (128 * 32));
4760 parm
[2] = cylinders
;
4766 * ipr_find_starget - Find target based on bus/target.
4767 * @starget: scsi target struct
4770 * resource entry pointer if found / NULL if not found
4772 static struct ipr_resource_entry
*ipr_find_starget(struct scsi_target
*starget
)
4774 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4775 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4776 struct ipr_resource_entry
*res
;
4778 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
4779 if ((res
->bus
== starget
->channel
) &&
4780 (res
->target
== starget
->id
)) {
4788 static struct ata_port_info sata_port_info
;
4791 * ipr_target_alloc - Prepare for commands to a SCSI target
4792 * @starget: scsi target struct
4794 * If the device is a SATA device, this function allocates an
4795 * ATA port with libata, else it does nothing.
4798 * 0 on success / non-0 on failure
4800 static int ipr_target_alloc(struct scsi_target
*starget
)
4802 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4803 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4804 struct ipr_sata_port
*sata_port
;
4805 struct ata_port
*ap
;
4806 struct ipr_resource_entry
*res
;
4807 unsigned long lock_flags
;
4809 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4810 res
= ipr_find_starget(starget
);
4811 starget
->hostdata
= NULL
;
4813 if (res
&& ipr_is_gata(res
)) {
4814 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4815 sata_port
= kzalloc(sizeof(*sata_port
), GFP_KERNEL
);
4819 ap
= ata_sas_port_alloc(&ioa_cfg
->ata_host
, &sata_port_info
, shost
);
4821 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4822 sata_port
->ioa_cfg
= ioa_cfg
;
4824 sata_port
->res
= res
;
4826 res
->sata_port
= sata_port
;
4827 ap
->private_data
= sata_port
;
4828 starget
->hostdata
= sata_port
;
4834 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4840 * ipr_target_destroy - Destroy a SCSI target
4841 * @starget: scsi target struct
4843 * If the device was a SATA device, this function frees the libata
4844 * ATA port, else it does nothing.
4847 static void ipr_target_destroy(struct scsi_target
*starget
)
4849 struct ipr_sata_port
*sata_port
= starget
->hostdata
;
4850 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4851 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4853 if (ioa_cfg
->sis64
) {
4854 if (!ipr_find_starget(starget
)) {
4855 if (starget
->channel
== IPR_ARRAY_VIRTUAL_BUS
)
4856 clear_bit(starget
->id
, ioa_cfg
->array_ids
);
4857 else if (starget
->channel
== IPR_VSET_VIRTUAL_BUS
)
4858 clear_bit(starget
->id
, ioa_cfg
->vset_ids
);
4859 else if (starget
->channel
== 0)
4860 clear_bit(starget
->id
, ioa_cfg
->target_ids
);
4865 starget
->hostdata
= NULL
;
4866 ata_sas_port_destroy(sata_port
->ap
);
4872 * ipr_find_sdev - Find device based on bus/target/lun.
4873 * @sdev: scsi device struct
4876 * resource entry pointer if found / NULL if not found
4878 static struct ipr_resource_entry
*ipr_find_sdev(struct scsi_device
*sdev
)
4880 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4881 struct ipr_resource_entry
*res
;
4883 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
4884 if ((res
->bus
== sdev
->channel
) &&
4885 (res
->target
== sdev
->id
) &&
4886 (res
->lun
== sdev
->lun
))
4894 * ipr_slave_destroy - Unconfigure a SCSI device
4895 * @sdev: scsi device struct
4900 static void ipr_slave_destroy(struct scsi_device
*sdev
)
4902 struct ipr_resource_entry
*res
;
4903 struct ipr_ioa_cfg
*ioa_cfg
;
4904 unsigned long lock_flags
= 0;
4906 ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4908 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4909 res
= (struct ipr_resource_entry
*) sdev
->hostdata
;
4912 res
->sata_port
->ap
->link
.device
[0].class = ATA_DEV_NONE
;
4913 sdev
->hostdata
= NULL
;
4915 res
->sata_port
= NULL
;
4917 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4921 * ipr_slave_configure - Configure a SCSI device
4922 * @sdev: scsi device struct
4924 * This function configures the specified scsi device.
4929 static int ipr_slave_configure(struct scsi_device
*sdev
)
4931 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4932 struct ipr_resource_entry
*res
;
4933 struct ata_port
*ap
= NULL
;
4934 unsigned long lock_flags
= 0;
4935 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
4937 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4938 res
= sdev
->hostdata
;
4940 if (ipr_is_af_dasd_device(res
))
4941 sdev
->type
= TYPE_RAID
;
4942 if (ipr_is_af_dasd_device(res
) || ipr_is_ioa_resource(res
)) {
4943 sdev
->scsi_level
= 4;
4944 sdev
->no_uld_attach
= 1;
4946 if (ipr_is_vset_device(res
)) {
4947 sdev
->scsi_level
= SCSI_SPC_3
;
4948 sdev
->no_report_opcodes
= 1;
4949 blk_queue_rq_timeout(sdev
->request_queue
,
4950 IPR_VSET_RW_TIMEOUT
);
4951 blk_queue_max_hw_sectors(sdev
->request_queue
, IPR_VSET_MAX_SECTORS
);
4953 if (ipr_is_gata(res
) && res
->sata_port
)
4954 ap
= res
->sata_port
->ap
;
4955 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4958 scsi_change_queue_depth(sdev
, IPR_MAX_CMD_PER_ATA_LUN
);
4959 ata_sas_slave_configure(sdev
, ap
);
4963 sdev_printk(KERN_INFO
, sdev
, "Resource path: %s\n",
4964 ipr_format_res_path(ioa_cfg
,
4965 res
->res_path
, buffer
, sizeof(buffer
)));
4968 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4973 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4974 * @sdev: scsi device struct
4976 * This function initializes an ATA port so that future commands
4977 * sent through queuecommand will work.
4982 static int ipr_ata_slave_alloc(struct scsi_device
*sdev
)
4984 struct ipr_sata_port
*sata_port
= NULL
;
4988 if (sdev
->sdev_target
)
4989 sata_port
= sdev
->sdev_target
->hostdata
;
4991 rc
= ata_sas_port_init(sata_port
->ap
);
4993 rc
= ata_sas_sync_probe(sata_port
->ap
);
4997 ipr_slave_destroy(sdev
);
5004 * ipr_slave_alloc - Prepare for commands to a device.
5005 * @sdev: scsi device struct
5007 * This function saves a pointer to the resource entry
5008 * in the scsi device struct if the device exists. We
5009 * can then use this pointer in ipr_queuecommand when
5010 * handling new commands.
5013 * 0 on success / -ENXIO if device does not exist
5015 static int ipr_slave_alloc(struct scsi_device
*sdev
)
5017 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
5018 struct ipr_resource_entry
*res
;
5019 unsigned long lock_flags
;
5022 sdev
->hostdata
= NULL
;
5024 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5026 res
= ipr_find_sdev(sdev
);
5031 sdev
->hostdata
= res
;
5032 if (!ipr_is_naca_model(res
))
5033 res
->needs_sync_complete
= 1;
5035 if (ipr_is_gata(res
)) {
5036 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5037 return ipr_ata_slave_alloc(sdev
);
5041 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5047 * ipr_match_lun - Match function for specified LUN
5048 * @ipr_cmd: ipr command struct
5049 * @device: device to match (sdev)
5052 * 1 if command matches sdev / 0 if command does not match sdev
5054 static int ipr_match_lun(struct ipr_cmnd
*ipr_cmd
, void *device
)
5056 if (ipr_cmd
->scsi_cmd
&& ipr_cmd
->scsi_cmd
->device
== device
)
5062 * ipr_cmnd_is_free - Check if a command is free or not
5063 * @ipr_cmd ipr command struct
5068 static bool ipr_cmnd_is_free(struct ipr_cmnd
*ipr_cmd
)
5070 struct ipr_cmnd
*loop_cmd
;
5072 list_for_each_entry(loop_cmd
, &ipr_cmd
->hrrq
->hrrq_free_q
, queue
) {
5073 if (loop_cmd
== ipr_cmd
)
5081 * ipr_match_res - Match function for specified resource entry
5082 * @ipr_cmd: ipr command struct
5083 * @resource: resource entry to match
5086 * 1 if command matches sdev / 0 if command does not match sdev
5088 static int ipr_match_res(struct ipr_cmnd
*ipr_cmd
, void *resource
)
5090 struct ipr_resource_entry
*res
= resource
;
5092 if (res
&& ipr_cmd
->ioarcb
.res_handle
== res
->res_handle
)
5098 * ipr_wait_for_ops - Wait for matching commands to complete
5099 * @ipr_cmd: ipr command struct
5100 * @device: device to match (sdev)
5101 * @match: match function to use
5106 static int ipr_wait_for_ops(struct ipr_ioa_cfg
*ioa_cfg
, void *device
,
5107 int (*match
)(struct ipr_cmnd
*, void *))
5109 struct ipr_cmnd
*ipr_cmd
;
5111 unsigned long flags
;
5112 struct ipr_hrr_queue
*hrrq
;
5113 signed long timeout
= IPR_ABORT_TASK_TIMEOUT
;
5114 DECLARE_COMPLETION_ONSTACK(comp
);
5120 for_each_hrrq(hrrq
, ioa_cfg
) {
5121 spin_lock_irqsave(hrrq
->lock
, flags
);
5122 for (i
= hrrq
->min_cmd_id
; i
<= hrrq
->max_cmd_id
; i
++) {
5123 ipr_cmd
= ioa_cfg
->ipr_cmnd_list
[i
];
5124 if (!ipr_cmnd_is_free(ipr_cmd
)) {
5125 if (match(ipr_cmd
, device
)) {
5126 ipr_cmd
->eh_comp
= &comp
;
5131 spin_unlock_irqrestore(hrrq
->lock
, flags
);
5135 timeout
= wait_for_completion_timeout(&comp
, timeout
);
5140 for_each_hrrq(hrrq
, ioa_cfg
) {
5141 spin_lock_irqsave(hrrq
->lock
, flags
);
5142 for (i
= hrrq
->min_cmd_id
; i
<= hrrq
->max_cmd_id
; i
++) {
5143 ipr_cmd
= ioa_cfg
->ipr_cmnd_list
[i
];
5144 if (!ipr_cmnd_is_free(ipr_cmd
)) {
5145 if (match(ipr_cmd
, device
)) {
5146 ipr_cmd
->eh_comp
= NULL
;
5151 spin_unlock_irqrestore(hrrq
->lock
, flags
);
5155 dev_err(&ioa_cfg
->pdev
->dev
, "Timed out waiting for aborted commands\n");
5157 return wait
? FAILED
: SUCCESS
;
5166 static int ipr_eh_host_reset(struct scsi_cmnd
*cmd
)
5168 struct ipr_ioa_cfg
*ioa_cfg
;
5169 unsigned long lock_flags
= 0;
5173 ioa_cfg
= (struct ipr_ioa_cfg
*) cmd
->device
->host
->hostdata
;
5174 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5176 if (!ioa_cfg
->in_reset_reload
&& !ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
5177 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_ABBREV
);
5178 dev_err(&ioa_cfg
->pdev
->dev
,
5179 "Adapter being reset as a result of error recovery.\n");
5181 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5182 ioa_cfg
->sdt_state
= GET_DUMP
;
5185 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5186 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
5187 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5189 /* If we got hit with a host reset while we were already resetting
5190 the adapter for some reason, and the reset failed. */
5191 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
5196 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5202 * ipr_device_reset - Reset the device
5203 * @ioa_cfg: ioa config struct
5204 * @res: resource entry struct
5206 * This function issues a device reset to the affected device.
5207 * If the device is a SCSI device, a LUN reset will be sent
5208 * to the device first. If that does not work, a target reset
5209 * will be sent. If the device is a SATA device, a PHY reset will
5213 * 0 on success / non-zero on failure
5215 static int ipr_device_reset(struct ipr_ioa_cfg
*ioa_cfg
,
5216 struct ipr_resource_entry
*res
)
5218 struct ipr_cmnd
*ipr_cmd
;
5219 struct ipr_ioarcb
*ioarcb
;
5220 struct ipr_cmd_pkt
*cmd_pkt
;
5221 struct ipr_ioarcb_ata_regs
*regs
;
5225 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5226 ioarcb
= &ipr_cmd
->ioarcb
;
5227 cmd_pkt
= &ioarcb
->cmd_pkt
;
5229 if (ipr_cmd
->ioa_cfg
->sis64
) {
5230 regs
= &ipr_cmd
->i
.ata_ioadl
.regs
;
5231 ioarcb
->add_cmd_parms_offset
= cpu_to_be16(sizeof(*ioarcb
));
5233 regs
= &ioarcb
->u
.add_data
.u
.regs
;
5235 ioarcb
->res_handle
= res
->res_handle
;
5236 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5237 cmd_pkt
->cdb
[0] = IPR_RESET_DEVICE
;
5238 if (ipr_is_gata(res
)) {
5239 cmd_pkt
->cdb
[2] = IPR_ATA_PHY_RESET
;
5240 ioarcb
->add_cmd_parms_len
= cpu_to_be16(sizeof(regs
->flags
));
5241 regs
->flags
|= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION
;
5244 ipr_send_blocking_cmd(ipr_cmd
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
5245 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5246 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5247 if (ipr_is_gata(res
) && res
->sata_port
&& ioasc
!= IPR_IOASC_IOA_WAS_RESET
) {
5248 if (ipr_cmd
->ioa_cfg
->sis64
)
5249 memcpy(&res
->sata_port
->ioasa
, &ipr_cmd
->s
.ioasa64
.u
.gata
,
5250 sizeof(struct ipr_ioasa_gata
));
5252 memcpy(&res
->sata_port
->ioasa
, &ipr_cmd
->s
.ioasa
.u
.gata
,
5253 sizeof(struct ipr_ioasa_gata
));
5257 return IPR_IOASC_SENSE_KEY(ioasc
) ? -EIO
: 0;
5261 * ipr_sata_reset - Reset the SATA port
5262 * @link: SATA link to reset
5263 * @classes: class of the attached device
5265 * This function issues a SATA phy reset to the affected ATA link.
5268 * 0 on success / non-zero on failure
5270 static int ipr_sata_reset(struct ata_link
*link
, unsigned int *classes
,
5271 unsigned long deadline
)
5273 struct ipr_sata_port
*sata_port
= link
->ap
->private_data
;
5274 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
5275 struct ipr_resource_entry
*res
;
5276 unsigned long lock_flags
= 0;
5277 int rc
= -ENXIO
, ret
;
5280 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5281 while (ioa_cfg
->in_reset_reload
) {
5282 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5283 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
5284 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5287 res
= sata_port
->res
;
5289 rc
= ipr_device_reset(ioa_cfg
, res
);
5290 *classes
= res
->ata_class
;
5291 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5293 ret
= ipr_wait_for_ops(ioa_cfg
, res
, ipr_match_res
);
5294 if (ret
!= SUCCESS
) {
5295 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5296 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_ABBREV
);
5297 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5299 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
5302 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5309 * ipr_eh_dev_reset - Reset the device
5310 * @scsi_cmd: scsi command struct
5312 * This function issues a device reset to the affected device.
5313 * A LUN reset will be sent to the device first. If that does
5314 * not work, a target reset will be sent.
5319 static int __ipr_eh_dev_reset(struct scsi_cmnd
*scsi_cmd
)
5321 struct ipr_cmnd
*ipr_cmd
;
5322 struct ipr_ioa_cfg
*ioa_cfg
;
5323 struct ipr_resource_entry
*res
;
5324 struct ata_port
*ap
;
5326 struct ipr_hrr_queue
*hrrq
;
5329 ioa_cfg
= (struct ipr_ioa_cfg
*) scsi_cmd
->device
->host
->hostdata
;
5330 res
= scsi_cmd
->device
->hostdata
;
5333 * If we are currently going through reset/reload, return failed. This will force the
5334 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
5337 if (ioa_cfg
->in_reset_reload
)
5339 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
5342 for_each_hrrq(hrrq
, ioa_cfg
) {
5343 spin_lock(&hrrq
->_lock
);
5344 for (i
= hrrq
->min_cmd_id
; i
<= hrrq
->max_cmd_id
; i
++) {
5345 ipr_cmd
= ioa_cfg
->ipr_cmnd_list
[i
];
5347 if (ipr_cmd
->ioarcb
.res_handle
== res
->res_handle
) {
5350 if (ipr_cmnd_is_free(ipr_cmd
))
5353 ipr_cmd
->done
= ipr_sata_eh_done
;
5354 if (!(ipr_cmd
->qc
->flags
& ATA_QCFLAG_FAILED
)) {
5355 ipr_cmd
->qc
->err_mask
|= AC_ERR_TIMEOUT
;
5356 ipr_cmd
->qc
->flags
|= ATA_QCFLAG_FAILED
;
5360 spin_unlock(&hrrq
->_lock
);
5362 res
->resetting_device
= 1;
5363 scmd_printk(KERN_ERR
, scsi_cmd
, "Resetting device\n");
5365 if (ipr_is_gata(res
) && res
->sata_port
) {
5366 ap
= res
->sata_port
->ap
;
5367 spin_unlock_irq(scsi_cmd
->device
->host
->host_lock
);
5368 ata_std_error_handler(ap
);
5369 spin_lock_irq(scsi_cmd
->device
->host
->host_lock
);
5371 rc
= ipr_device_reset(ioa_cfg
, res
);
5372 res
->resetting_device
= 0;
5373 res
->reset_occurred
= 1;
5376 return rc
? FAILED
: SUCCESS
;
5379 static int ipr_eh_dev_reset(struct scsi_cmnd
*cmd
)
5382 struct ipr_ioa_cfg
*ioa_cfg
;
5383 struct ipr_resource_entry
*res
;
5385 ioa_cfg
= (struct ipr_ioa_cfg
*) cmd
->device
->host
->hostdata
;
5386 res
= cmd
->device
->hostdata
;
5391 spin_lock_irq(cmd
->device
->host
->host_lock
);
5392 rc
= __ipr_eh_dev_reset(cmd
);
5393 spin_unlock_irq(cmd
->device
->host
->host_lock
);
5395 if (rc
== SUCCESS
) {
5396 if (ipr_is_gata(res
) && res
->sata_port
)
5397 rc
= ipr_wait_for_ops(ioa_cfg
, res
, ipr_match_res
);
5399 rc
= ipr_wait_for_ops(ioa_cfg
, cmd
->device
, ipr_match_lun
);
5406 * ipr_bus_reset_done - Op done function for bus reset.
5407 * @ipr_cmd: ipr command struct
5409 * This function is the op done function for a bus reset
5414 static void ipr_bus_reset_done(struct ipr_cmnd
*ipr_cmd
)
5416 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
5417 struct ipr_resource_entry
*res
;
5420 if (!ioa_cfg
->sis64
)
5421 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
5422 if (res
->res_handle
== ipr_cmd
->ioarcb
.res_handle
) {
5423 scsi_report_bus_reset(ioa_cfg
->host
, res
->bus
);
5429 * If abort has not completed, indicate the reset has, else call the
5430 * abort's done function to wake the sleeping eh thread
5432 if (ipr_cmd
->sibling
->sibling
)
5433 ipr_cmd
->sibling
->sibling
= NULL
;
5435 ipr_cmd
->sibling
->done(ipr_cmd
->sibling
);
5437 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5442 * ipr_abort_timeout - An abort task has timed out
5443 * @ipr_cmd: ipr command struct
5445 * This function handles when an abort task times out. If this
5446 * happens we issue a bus reset since we have resources tied
5447 * up that must be freed before returning to the midlayer.
5452 static void ipr_abort_timeout(struct timer_list
*t
)
5454 struct ipr_cmnd
*ipr_cmd
= from_timer(ipr_cmd
, t
, timer
);
5455 struct ipr_cmnd
*reset_cmd
;
5456 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
5457 struct ipr_cmd_pkt
*cmd_pkt
;
5458 unsigned long lock_flags
= 0;
5461 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5462 if (ipr_cmd
->completion
.done
|| ioa_cfg
->in_reset_reload
) {
5463 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5467 sdev_printk(KERN_ERR
, ipr_cmd
->u
.sdev
, "Abort timed out. Resetting bus.\n");
5468 reset_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5469 ipr_cmd
->sibling
= reset_cmd
;
5470 reset_cmd
->sibling
= ipr_cmd
;
5471 reset_cmd
->ioarcb
.res_handle
= ipr_cmd
->ioarcb
.res_handle
;
5472 cmd_pkt
= &reset_cmd
->ioarcb
.cmd_pkt
;
5473 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5474 cmd_pkt
->cdb
[0] = IPR_RESET_DEVICE
;
5475 cmd_pkt
->cdb
[2] = IPR_RESET_TYPE_SELECT
| IPR_BUS_RESET
;
5477 ipr_do_req(reset_cmd
, ipr_bus_reset_done
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
5478 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5483 * ipr_cancel_op - Cancel specified op
5484 * @scsi_cmd: scsi command struct
5486 * This function cancels specified op.
5491 static int ipr_cancel_op(struct scsi_cmnd
*scsi_cmd
)
5493 struct ipr_cmnd
*ipr_cmd
;
5494 struct ipr_ioa_cfg
*ioa_cfg
;
5495 struct ipr_resource_entry
*res
;
5496 struct ipr_cmd_pkt
*cmd_pkt
;
5498 int i
, op_found
= 0;
5499 struct ipr_hrr_queue
*hrrq
;
5502 ioa_cfg
= (struct ipr_ioa_cfg
*)scsi_cmd
->device
->host
->hostdata
;
5503 res
= scsi_cmd
->device
->hostdata
;
5505 /* If we are currently going through reset/reload, return failed.
5506 * This will force the mid-layer to call ipr_eh_host_reset,
5507 * which will then go to sleep and wait for the reset to complete
5509 if (ioa_cfg
->in_reset_reload
||
5510 ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
5516 * If we are aborting a timed out op, chances are that the timeout was caused
5517 * by a still not detected EEH error. In such cases, reading a register will
5518 * trigger the EEH recovery infrastructure.
5520 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
5522 if (!ipr_is_gscsi(res
))
5525 for_each_hrrq(hrrq
, ioa_cfg
) {
5526 spin_lock(&hrrq
->_lock
);
5527 for (i
= hrrq
->min_cmd_id
; i
<= hrrq
->max_cmd_id
; i
++) {
5528 if (ioa_cfg
->ipr_cmnd_list
[i
]->scsi_cmd
== scsi_cmd
) {
5529 if (!ipr_cmnd_is_free(ioa_cfg
->ipr_cmnd_list
[i
])) {
5535 spin_unlock(&hrrq
->_lock
);
5541 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5542 ipr_cmd
->ioarcb
.res_handle
= res
->res_handle
;
5543 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
5544 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5545 cmd_pkt
->cdb
[0] = IPR_CANCEL_ALL_REQUESTS
;
5546 ipr_cmd
->u
.sdev
= scsi_cmd
->device
;
5548 scmd_printk(KERN_ERR
, scsi_cmd
, "Aborting command: %02X\n",
5550 ipr_send_blocking_cmd(ipr_cmd
, ipr_abort_timeout
, IPR_CANCEL_ALL_TIMEOUT
);
5551 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5554 * If the abort task timed out and we sent a bus reset, we will get
5555 * one the following responses to the abort
5557 if (ioasc
== IPR_IOASC_BUS_WAS_RESET
|| ioasc
== IPR_IOASC_SYNC_REQUIRED
) {
5562 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5563 if (!ipr_is_naca_model(res
))
5564 res
->needs_sync_complete
= 1;
5567 return IPR_IOASC_SENSE_KEY(ioasc
) ? FAILED
: SUCCESS
;
5571 * ipr_eh_abort - Abort a single op
5572 * @scsi_cmd: scsi command struct
5575 * 0 if scan in progress / 1 if scan is complete
5577 static int ipr_scan_finished(struct Scsi_Host
*shost
, unsigned long elapsed_time
)
5579 unsigned long lock_flags
;
5580 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
5583 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
5584 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
|| ioa_cfg
->scan_done
)
5586 if ((elapsed_time
/HZ
) > (ioa_cfg
->transop_timeout
* 2))
5588 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
5593 * ipr_eh_host_reset - Reset the host adapter
5594 * @scsi_cmd: scsi command struct
5599 static int ipr_eh_abort(struct scsi_cmnd
*scsi_cmd
)
5601 unsigned long flags
;
5603 struct ipr_ioa_cfg
*ioa_cfg
;
5607 ioa_cfg
= (struct ipr_ioa_cfg
*) scsi_cmd
->device
->host
->hostdata
;
5609 spin_lock_irqsave(scsi_cmd
->device
->host
->host_lock
, flags
);
5610 rc
= ipr_cancel_op(scsi_cmd
);
5611 spin_unlock_irqrestore(scsi_cmd
->device
->host
->host_lock
, flags
);
5614 rc
= ipr_wait_for_ops(ioa_cfg
, scsi_cmd
->device
, ipr_match_lun
);
5620 * ipr_handle_other_interrupt - Handle "other" interrupts
5621 * @ioa_cfg: ioa config struct
5622 * @int_reg: interrupt register
5625 * IRQ_NONE / IRQ_HANDLED
5627 static irqreturn_t
ipr_handle_other_interrupt(struct ipr_ioa_cfg
*ioa_cfg
,
5630 irqreturn_t rc
= IRQ_HANDLED
;
5633 int_mask_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg32
);
5634 int_reg
&= ~int_mask_reg
;
5636 /* If an interrupt on the adapter did not occur, ignore it.
5637 * Or in the case of SIS 64, check for a stage change interrupt.
5639 if ((int_reg
& IPR_PCII_OPER_INTERRUPTS
) == 0) {
5640 if (ioa_cfg
->sis64
) {
5641 int_mask_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
5642 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
) & ~int_mask_reg
;
5643 if (int_reg
& IPR_PCII_IPL_STAGE_CHANGE
) {
5645 /* clear stage change */
5646 writel(IPR_PCII_IPL_STAGE_CHANGE
, ioa_cfg
->regs
.clr_interrupt_reg
);
5647 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
) & ~int_mask_reg
;
5648 list_del(&ioa_cfg
->reset_cmd
->queue
);
5649 del_timer(&ioa_cfg
->reset_cmd
->timer
);
5650 ipr_reset_ioa_job(ioa_cfg
->reset_cmd
);
5658 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
5659 /* Mask the interrupt */
5660 writel(IPR_PCII_IOA_TRANS_TO_OPER
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
5661 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
5663 list_del(&ioa_cfg
->reset_cmd
->queue
);
5664 del_timer(&ioa_cfg
->reset_cmd
->timer
);
5665 ipr_reset_ioa_job(ioa_cfg
->reset_cmd
);
5666 } else if ((int_reg
& IPR_PCII_HRRQ_UPDATED
) == int_reg
) {
5667 if (ioa_cfg
->clear_isr
) {
5668 if (ipr_debug
&& printk_ratelimit())
5669 dev_err(&ioa_cfg
->pdev
->dev
,
5670 "Spurious interrupt detected. 0x%08X\n", int_reg
);
5671 writel(IPR_PCII_HRRQ_UPDATED
, ioa_cfg
->regs
.clr_interrupt_reg32
);
5672 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5676 if (int_reg
& IPR_PCII_IOA_UNIT_CHECKED
)
5677 ioa_cfg
->ioa_unit_checked
= 1;
5678 else if (int_reg
& IPR_PCII_NO_HOST_RRQ
)
5679 dev_err(&ioa_cfg
->pdev
->dev
,
5680 "No Host RRQ. 0x%08X\n", int_reg
);
5682 dev_err(&ioa_cfg
->pdev
->dev
,
5683 "Permanent IOA failure. 0x%08X\n", int_reg
);
5685 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5686 ioa_cfg
->sdt_state
= GET_DUMP
;
5688 ipr_mask_and_clear_interrupts(ioa_cfg
, ~0);
5689 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
5696 * ipr_isr_eh - Interrupt service routine error handler
5697 * @ioa_cfg: ioa config struct
5698 * @msg: message to log
5703 static void ipr_isr_eh(struct ipr_ioa_cfg
*ioa_cfg
, char *msg
, u16 number
)
5705 ioa_cfg
->errors_logged
++;
5706 dev_err(&ioa_cfg
->pdev
->dev
, "%s %d\n", msg
, number
);
5708 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5709 ioa_cfg
->sdt_state
= GET_DUMP
;
5711 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
5714 static int ipr_process_hrrq(struct ipr_hrr_queue
*hrr_queue
, int budget
,
5715 struct list_head
*doneq
)
5719 struct ipr_cmnd
*ipr_cmd
;
5720 struct ipr_ioa_cfg
*ioa_cfg
= hrr_queue
->ioa_cfg
;
5723 /* If interrupts are disabled, ignore the interrupt */
5724 if (!hrr_queue
->allow_interrupts
)
5727 while ((be32_to_cpu(*hrr_queue
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5728 hrr_queue
->toggle_bit
) {
5730 cmd_index
= (be32_to_cpu(*hrr_queue
->hrrq_curr
) &
5731 IPR_HRRQ_REQ_RESP_HANDLE_MASK
) >>
5732 IPR_HRRQ_REQ_RESP_HANDLE_SHIFT
;
5734 if (unlikely(cmd_index
> hrr_queue
->max_cmd_id
||
5735 cmd_index
< hrr_queue
->min_cmd_id
)) {
5737 "Invalid response handle from IOA: ",
5742 ipr_cmd
= ioa_cfg
->ipr_cmnd_list
[cmd_index
];
5743 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5745 ipr_trc_hook(ipr_cmd
, IPR_TRACE_FINISH
, ioasc
);
5747 list_move_tail(&ipr_cmd
->queue
, doneq
);
5749 if (hrr_queue
->hrrq_curr
< hrr_queue
->hrrq_end
) {
5750 hrr_queue
->hrrq_curr
++;
5752 hrr_queue
->hrrq_curr
= hrr_queue
->hrrq_start
;
5753 hrr_queue
->toggle_bit
^= 1u;
5756 if (budget
> 0 && num_hrrq
>= budget
)
5763 static int ipr_iopoll(struct irq_poll
*iop
, int budget
)
5765 struct ipr_ioa_cfg
*ioa_cfg
;
5766 struct ipr_hrr_queue
*hrrq
;
5767 struct ipr_cmnd
*ipr_cmd
, *temp
;
5768 unsigned long hrrq_flags
;
5772 hrrq
= container_of(iop
, struct ipr_hrr_queue
, iopoll
);
5773 ioa_cfg
= hrrq
->ioa_cfg
;
5775 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5776 completed_ops
= ipr_process_hrrq(hrrq
, budget
, &doneq
);
5778 if (completed_ops
< budget
)
5779 irq_poll_complete(iop
);
5780 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5782 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5783 list_del(&ipr_cmd
->queue
);
5784 del_timer(&ipr_cmd
->timer
);
5785 ipr_cmd
->fast_done(ipr_cmd
);
5788 return completed_ops
;
5792 * ipr_isr - Interrupt service routine
5794 * @devp: pointer to ioa config struct
5797 * IRQ_NONE / IRQ_HANDLED
5799 static irqreturn_t
ipr_isr(int irq
, void *devp
)
5801 struct ipr_hrr_queue
*hrrq
= (struct ipr_hrr_queue
*)devp
;
5802 struct ipr_ioa_cfg
*ioa_cfg
= hrrq
->ioa_cfg
;
5803 unsigned long hrrq_flags
= 0;
5807 struct ipr_cmnd
*ipr_cmd
, *temp
;
5808 irqreturn_t rc
= IRQ_NONE
;
5811 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5812 /* If interrupts are disabled, ignore the interrupt */
5813 if (!hrrq
->allow_interrupts
) {
5814 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5819 if (ipr_process_hrrq(hrrq
, -1, &doneq
)) {
5822 if (!ioa_cfg
->clear_isr
)
5825 /* Clear the PCI interrupt */
5828 writel(IPR_PCII_HRRQ_UPDATED
,
5829 ioa_cfg
->regs
.clr_interrupt_reg32
);
5830 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5831 } while (int_reg
& IPR_PCII_HRRQ_UPDATED
&&
5832 num_hrrq
++ < IPR_MAX_HRRQ_RETRIES
);
5834 } else if (rc
== IRQ_NONE
&& irq_none
== 0) {
5835 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5837 } else if (num_hrrq
== IPR_MAX_HRRQ_RETRIES
&&
5838 int_reg
& IPR_PCII_HRRQ_UPDATED
) {
5840 "Error clearing HRRQ: ", num_hrrq
);
5847 if (unlikely(rc
== IRQ_NONE
))
5848 rc
= ipr_handle_other_interrupt(ioa_cfg
, int_reg
);
5850 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5851 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5852 list_del(&ipr_cmd
->queue
);
5853 del_timer(&ipr_cmd
->timer
);
5854 ipr_cmd
->fast_done(ipr_cmd
);
5860 * ipr_isr_mhrrq - Interrupt service routine
5862 * @devp: pointer to ioa config struct
5865 * IRQ_NONE / IRQ_HANDLED
5867 static irqreturn_t
ipr_isr_mhrrq(int irq
, void *devp
)
5869 struct ipr_hrr_queue
*hrrq
= (struct ipr_hrr_queue
*)devp
;
5870 struct ipr_ioa_cfg
*ioa_cfg
= hrrq
->ioa_cfg
;
5871 unsigned long hrrq_flags
= 0;
5872 struct ipr_cmnd
*ipr_cmd
, *temp
;
5873 irqreturn_t rc
= IRQ_NONE
;
5876 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5878 /* If interrupts are disabled, ignore the interrupt */
5879 if (!hrrq
->allow_interrupts
) {
5880 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5884 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
5885 if ((be32_to_cpu(*hrrq
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5887 irq_poll_sched(&hrrq
->iopoll
);
5888 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5892 if ((be32_to_cpu(*hrrq
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5895 if (ipr_process_hrrq(hrrq
, -1, &doneq
))
5899 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5901 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5902 list_del(&ipr_cmd
->queue
);
5903 del_timer(&ipr_cmd
->timer
);
5904 ipr_cmd
->fast_done(ipr_cmd
);
5910 * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5911 * @ioa_cfg: ioa config struct
5912 * @ipr_cmd: ipr command struct
5915 * 0 on success / -1 on failure
5917 static int ipr_build_ioadl64(struct ipr_ioa_cfg
*ioa_cfg
,
5918 struct ipr_cmnd
*ipr_cmd
)
5921 struct scatterlist
*sg
;
5923 u32 ioadl_flags
= 0;
5924 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5925 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
5926 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ioadl64
;
5928 length
= scsi_bufflen(scsi_cmd
);
5932 nseg
= scsi_dma_map(scsi_cmd
);
5934 if (printk_ratelimit())
5935 dev_err(&ioa_cfg
->pdev
->dev
, "scsi_dma_map failed!\n");
5939 ipr_cmd
->dma_use_sg
= nseg
;
5941 ioarcb
->data_transfer_length
= cpu_to_be32(length
);
5943 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
5945 if (scsi_cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
5946 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
5947 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
5948 } else if (scsi_cmd
->sc_data_direction
== DMA_FROM_DEVICE
)
5949 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
5951 scsi_for_each_sg(scsi_cmd
, sg
, ipr_cmd
->dma_use_sg
, i
) {
5952 ioadl64
[i
].flags
= cpu_to_be32(ioadl_flags
);
5953 ioadl64
[i
].data_len
= cpu_to_be32(sg_dma_len(sg
));
5954 ioadl64
[i
].address
= cpu_to_be64(sg_dma_address(sg
));
5957 ioadl64
[i
-1].flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
5962 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5963 * @ioa_cfg: ioa config struct
5964 * @ipr_cmd: ipr command struct
5967 * 0 on success / -1 on failure
5969 static int ipr_build_ioadl(struct ipr_ioa_cfg
*ioa_cfg
,
5970 struct ipr_cmnd
*ipr_cmd
)
5973 struct scatterlist
*sg
;
5975 u32 ioadl_flags
= 0;
5976 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5977 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
5978 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
5980 length
= scsi_bufflen(scsi_cmd
);
5984 nseg
= scsi_dma_map(scsi_cmd
);
5986 dev_err(&ioa_cfg
->pdev
->dev
, "scsi_dma_map failed!\n");
5990 ipr_cmd
->dma_use_sg
= nseg
;
5992 if (scsi_cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
5993 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
5994 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
5995 ioarcb
->data_transfer_length
= cpu_to_be32(length
);
5997 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
5998 } else if (scsi_cmd
->sc_data_direction
== DMA_FROM_DEVICE
) {
5999 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
6000 ioarcb
->read_data_transfer_length
= cpu_to_be32(length
);
6001 ioarcb
->read_ioadl_len
=
6002 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
6005 if (ipr_cmd
->dma_use_sg
<= ARRAY_SIZE(ioarcb
->u
.add_data
.u
.ioadl
)) {
6006 ioadl
= ioarcb
->u
.add_data
.u
.ioadl
;
6007 ioarcb
->write_ioadl_addr
= cpu_to_be32((ipr_cmd
->dma_addr
) +
6008 offsetof(struct ipr_ioarcb
, u
.add_data
));
6009 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
6012 scsi_for_each_sg(scsi_cmd
, sg
, ipr_cmd
->dma_use_sg
, i
) {
6013 ioadl
[i
].flags_and_data_len
=
6014 cpu_to_be32(ioadl_flags
| sg_dma_len(sg
));
6015 ioadl
[i
].address
= cpu_to_be32(sg_dma_address(sg
));
6018 ioadl
[i
-1].flags_and_data_len
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
6023 * __ipr_erp_done - Process completion of ERP for a device
6024 * @ipr_cmd: ipr command struct
6026 * This function copies the sense buffer into the scsi_cmd
6027 * struct and pushes the scsi_done function.
6032 static void __ipr_erp_done(struct ipr_cmnd
*ipr_cmd
)
6034 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6035 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
6036 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6038 if (IPR_IOASC_SENSE_KEY(ioasc
) > 0) {
6039 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6040 scmd_printk(KERN_ERR
, scsi_cmd
,
6041 "Request Sense failed with IOASC: 0x%08X\n", ioasc
);
6043 memcpy(scsi_cmd
->sense_buffer
, ipr_cmd
->sense_buffer
,
6044 SCSI_SENSE_BUFFERSIZE
);
6048 if (!ipr_is_naca_model(res
))
6049 res
->needs_sync_complete
= 1;
6052 scsi_dma_unmap(ipr_cmd
->scsi_cmd
);
6053 scsi_cmd
->scsi_done(scsi_cmd
);
6054 if (ipr_cmd
->eh_comp
)
6055 complete(ipr_cmd
->eh_comp
);
6056 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6060 * ipr_erp_done - Process completion of ERP for a device
6061 * @ipr_cmd: ipr command struct
6063 * This function copies the sense buffer into the scsi_cmd
6064 * struct and pushes the scsi_done function.
6069 static void ipr_erp_done(struct ipr_cmnd
*ipr_cmd
)
6071 struct ipr_hrr_queue
*hrrq
= ipr_cmd
->hrrq
;
6072 unsigned long hrrq_flags
;
6074 spin_lock_irqsave(&hrrq
->_lock
, hrrq_flags
);
6075 __ipr_erp_done(ipr_cmd
);
6076 spin_unlock_irqrestore(&hrrq
->_lock
, hrrq_flags
);
6080 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
6081 * @ipr_cmd: ipr command struct
6086 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd
*ipr_cmd
)
6088 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
6089 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6090 dma_addr_t dma_addr
= ipr_cmd
->dma_addr
;
6092 memset(&ioarcb
->cmd_pkt
, 0, sizeof(struct ipr_cmd_pkt
));
6093 ioarcb
->data_transfer_length
= 0;
6094 ioarcb
->read_data_transfer_length
= 0;
6095 ioarcb
->ioadl_len
= 0;
6096 ioarcb
->read_ioadl_len
= 0;
6097 ioasa
->hdr
.ioasc
= 0;
6098 ioasa
->hdr
.residual_data_len
= 0;
6100 if (ipr_cmd
->ioa_cfg
->sis64
)
6101 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
6102 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl64
));
6104 ioarcb
->write_ioadl_addr
=
6105 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl
));
6106 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
6111 * __ipr_erp_request_sense - Send request sense to a device
6112 * @ipr_cmd: ipr command struct
6114 * This function sends a request sense to a device as a result
6115 * of a check condition.
6120 static void __ipr_erp_request_sense(struct ipr_cmnd
*ipr_cmd
)
6122 struct ipr_cmd_pkt
*cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
6123 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6125 if (IPR_IOASC_SENSE_KEY(ioasc
) > 0) {
6126 __ipr_erp_done(ipr_cmd
);
6130 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd
);
6132 cmd_pkt
->request_type
= IPR_RQTYPE_SCSICDB
;
6133 cmd_pkt
->cdb
[0] = REQUEST_SENSE
;
6134 cmd_pkt
->cdb
[4] = SCSI_SENSE_BUFFERSIZE
;
6135 cmd_pkt
->flags_hi
|= IPR_FLAGS_HI_SYNC_OVERRIDE
;
6136 cmd_pkt
->flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6137 cmd_pkt
->timeout
= cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT
/ HZ
);
6139 ipr_init_ioadl(ipr_cmd
, ipr_cmd
->sense_buffer_dma
,
6140 SCSI_SENSE_BUFFERSIZE
, IPR_IOADL_FLAGS_READ_LAST
);
6142 ipr_do_req(ipr_cmd
, ipr_erp_done
, ipr_timeout
,
6143 IPR_REQUEST_SENSE_TIMEOUT
* 2);
6147 * ipr_erp_request_sense - Send request sense to a device
6148 * @ipr_cmd: ipr command struct
6150 * This function sends a request sense to a device as a result
6151 * of a check condition.
6156 static void ipr_erp_request_sense(struct ipr_cmnd
*ipr_cmd
)
6158 struct ipr_hrr_queue
*hrrq
= ipr_cmd
->hrrq
;
6159 unsigned long hrrq_flags
;
6161 spin_lock_irqsave(&hrrq
->_lock
, hrrq_flags
);
6162 __ipr_erp_request_sense(ipr_cmd
);
6163 spin_unlock_irqrestore(&hrrq
->_lock
, hrrq_flags
);
6167 * ipr_erp_cancel_all - Send cancel all to a device
6168 * @ipr_cmd: ipr command struct
6170 * This function sends a cancel all to a device to clear the
6171 * queue. If we are running TCQ on the device, QERR is set to 1,
6172 * which means all outstanding ops have been dropped on the floor.
6173 * Cancel all will return them to us.
6178 static void ipr_erp_cancel_all(struct ipr_cmnd
*ipr_cmd
)
6180 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6181 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
6182 struct ipr_cmd_pkt
*cmd_pkt
;
6186 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd
);
6188 if (!scsi_cmd
->device
->simple_tags
) {
6189 __ipr_erp_request_sense(ipr_cmd
);
6193 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
6194 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
6195 cmd_pkt
->cdb
[0] = IPR_CANCEL_ALL_REQUESTS
;
6197 ipr_do_req(ipr_cmd
, ipr_erp_request_sense
, ipr_timeout
,
6198 IPR_CANCEL_ALL_TIMEOUT
);
6202 * ipr_dump_ioasa - Dump contents of IOASA
6203 * @ioa_cfg: ioa config struct
6204 * @ipr_cmd: ipr command struct
6205 * @res: resource entry struct
6207 * This function is invoked by the interrupt handler when ops
6208 * fail. It will log the IOASA if appropriate. Only called
6214 static void ipr_dump_ioasa(struct ipr_ioa_cfg
*ioa_cfg
,
6215 struct ipr_cmnd
*ipr_cmd
, struct ipr_resource_entry
*res
)
6219 u32 ioasc
, fd_ioasc
;
6220 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6221 __be32
*ioasa_data
= (__be32
*)ioasa
;
6224 ioasc
= be32_to_cpu(ioasa
->hdr
.ioasc
) & IPR_IOASC_IOASC_MASK
;
6225 fd_ioasc
= be32_to_cpu(ioasa
->hdr
.fd_ioasc
) & IPR_IOASC_IOASC_MASK
;
6230 if (ioa_cfg
->log_level
< IPR_DEFAULT_LOG_LEVEL
)
6233 if (ioasc
== IPR_IOASC_BUS_WAS_RESET
&& fd_ioasc
)
6234 error_index
= ipr_get_error(fd_ioasc
);
6236 error_index
= ipr_get_error(ioasc
);
6238 if (ioa_cfg
->log_level
< IPR_MAX_LOG_LEVEL
) {
6239 /* Don't log an error if the IOA already logged one */
6240 if (ioasa
->hdr
.ilid
!= 0)
6243 if (!ipr_is_gscsi(res
))
6246 if (ipr_error_table
[error_index
].log_ioasa
== 0)
6250 ipr_res_err(ioa_cfg
, res
, "%s\n", ipr_error_table
[error_index
].error
);
6252 data_len
= be16_to_cpu(ioasa
->hdr
.ret_stat_len
);
6253 if (ioa_cfg
->sis64
&& sizeof(struct ipr_ioasa64
) < data_len
)
6254 data_len
= sizeof(struct ipr_ioasa64
);
6255 else if (!ioa_cfg
->sis64
&& sizeof(struct ipr_ioasa
) < data_len
)
6256 data_len
= sizeof(struct ipr_ioasa
);
6258 ipr_err("IOASA Dump:\n");
6260 for (i
= 0; i
< data_len
/ 4; i
+= 4) {
6261 ipr_err("%08X: %08X %08X %08X %08X\n", i
*4,
6262 be32_to_cpu(ioasa_data
[i
]),
6263 be32_to_cpu(ioasa_data
[i
+1]),
6264 be32_to_cpu(ioasa_data
[i
+2]),
6265 be32_to_cpu(ioasa_data
[i
+3]));
6270 * ipr_gen_sense - Generate SCSI sense data from an IOASA
6272 * @sense_buf: sense data buffer
6277 static void ipr_gen_sense(struct ipr_cmnd
*ipr_cmd
)
6280 u8
*sense_buf
= ipr_cmd
->scsi_cmd
->sense_buffer
;
6281 struct ipr_resource_entry
*res
= ipr_cmd
->scsi_cmd
->device
->hostdata
;
6282 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6283 u32 ioasc
= be32_to_cpu(ioasa
->hdr
.ioasc
);
6285 memset(sense_buf
, 0, SCSI_SENSE_BUFFERSIZE
);
6287 if (ioasc
>= IPR_FIRST_DRIVER_IOASC
)
6290 ipr_cmd
->scsi_cmd
->result
= SAM_STAT_CHECK_CONDITION
;
6292 if (ipr_is_vset_device(res
) &&
6293 ioasc
== IPR_IOASC_MED_DO_NOT_REALLOC
&&
6294 ioasa
->u
.vset
.failing_lba_hi
!= 0) {
6295 sense_buf
[0] = 0x72;
6296 sense_buf
[1] = IPR_IOASC_SENSE_KEY(ioasc
);
6297 sense_buf
[2] = IPR_IOASC_SENSE_CODE(ioasc
);
6298 sense_buf
[3] = IPR_IOASC_SENSE_QUAL(ioasc
);
6302 sense_buf
[9] = 0x0A;
6303 sense_buf
[10] = 0x80;
6305 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_hi
);
6307 sense_buf
[12] = (failing_lba
& 0xff000000) >> 24;
6308 sense_buf
[13] = (failing_lba
& 0x00ff0000) >> 16;
6309 sense_buf
[14] = (failing_lba
& 0x0000ff00) >> 8;
6310 sense_buf
[15] = failing_lba
& 0x000000ff;
6312 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_lo
);
6314 sense_buf
[16] = (failing_lba
& 0xff000000) >> 24;
6315 sense_buf
[17] = (failing_lba
& 0x00ff0000) >> 16;
6316 sense_buf
[18] = (failing_lba
& 0x0000ff00) >> 8;
6317 sense_buf
[19] = failing_lba
& 0x000000ff;
6319 sense_buf
[0] = 0x70;
6320 sense_buf
[2] = IPR_IOASC_SENSE_KEY(ioasc
);
6321 sense_buf
[12] = IPR_IOASC_SENSE_CODE(ioasc
);
6322 sense_buf
[13] = IPR_IOASC_SENSE_QUAL(ioasc
);
6324 /* Illegal request */
6325 if ((IPR_IOASC_SENSE_KEY(ioasc
) == 0x05) &&
6326 (be32_to_cpu(ioasa
->hdr
.ioasc_specific
) & IPR_FIELD_POINTER_VALID
)) {
6327 sense_buf
[7] = 10; /* additional length */
6329 /* IOARCB was in error */
6330 if (IPR_IOASC_SENSE_CODE(ioasc
) == 0x24)
6331 sense_buf
[15] = 0xC0;
6332 else /* Parameter data was invalid */
6333 sense_buf
[15] = 0x80;
6336 ((IPR_FIELD_POINTER_MASK
&
6337 be32_to_cpu(ioasa
->hdr
.ioasc_specific
)) >> 8) & 0xff;
6339 (IPR_FIELD_POINTER_MASK
&
6340 be32_to_cpu(ioasa
->hdr
.ioasc_specific
)) & 0xff;
6342 if (ioasc
== IPR_IOASC_MED_DO_NOT_REALLOC
) {
6343 if (ipr_is_vset_device(res
))
6344 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_lo
);
6346 failing_lba
= be32_to_cpu(ioasa
->u
.dasd
.failing_lba
);
6348 sense_buf
[0] |= 0x80; /* Or in the Valid bit */
6349 sense_buf
[3] = (failing_lba
& 0xff000000) >> 24;
6350 sense_buf
[4] = (failing_lba
& 0x00ff0000) >> 16;
6351 sense_buf
[5] = (failing_lba
& 0x0000ff00) >> 8;
6352 sense_buf
[6] = failing_lba
& 0x000000ff;
6355 sense_buf
[7] = 6; /* additional length */
6361 * ipr_get_autosense - Copy autosense data to sense buffer
6362 * @ipr_cmd: ipr command struct
6364 * This function copies the autosense buffer to the buffer
6365 * in the scsi_cmd, if there is autosense available.
6368 * 1 if autosense was available / 0 if not
6370 static int ipr_get_autosense(struct ipr_cmnd
*ipr_cmd
)
6372 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6373 struct ipr_ioasa64
*ioasa64
= &ipr_cmd
->s
.ioasa64
;
6375 if ((be32_to_cpu(ioasa
->hdr
.ioasc_specific
) & IPR_AUTOSENSE_VALID
) == 0)
6378 if (ipr_cmd
->ioa_cfg
->sis64
)
6379 memcpy(ipr_cmd
->scsi_cmd
->sense_buffer
, ioasa64
->auto_sense
.data
,
6380 min_t(u16
, be16_to_cpu(ioasa64
->auto_sense
.auto_sense_len
),
6381 SCSI_SENSE_BUFFERSIZE
));
6383 memcpy(ipr_cmd
->scsi_cmd
->sense_buffer
, ioasa
->auto_sense
.data
,
6384 min_t(u16
, be16_to_cpu(ioasa
->auto_sense
.auto_sense_len
),
6385 SCSI_SENSE_BUFFERSIZE
));
6390 * ipr_erp_start - Process an error response for a SCSI op
6391 * @ioa_cfg: ioa config struct
6392 * @ipr_cmd: ipr command struct
6394 * This function determines whether or not to initiate ERP
6395 * on the affected device.
6400 static void ipr_erp_start(struct ipr_ioa_cfg
*ioa_cfg
,
6401 struct ipr_cmnd
*ipr_cmd
)
6403 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6404 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
6405 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6406 u32 masked_ioasc
= ioasc
& IPR_IOASC_IOASC_MASK
;
6409 __ipr_scsi_eh_done(ipr_cmd
);
6413 if (!ipr_is_gscsi(res
) && masked_ioasc
!= IPR_IOASC_HW_DEV_BUS_STATUS
)
6414 ipr_gen_sense(ipr_cmd
);
6416 ipr_dump_ioasa(ioa_cfg
, ipr_cmd
, res
);
6418 switch (masked_ioasc
) {
6419 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST
:
6420 if (ipr_is_naca_model(res
))
6421 scsi_cmd
->result
|= (DID_ABORT
<< 16);
6423 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6425 case IPR_IOASC_IR_RESOURCE_HANDLE
:
6426 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA
:
6427 scsi_cmd
->result
|= (DID_NO_CONNECT
<< 16);
6429 case IPR_IOASC_HW_SEL_TIMEOUT
:
6430 scsi_cmd
->result
|= (DID_NO_CONNECT
<< 16);
6431 if (!ipr_is_naca_model(res
))
6432 res
->needs_sync_complete
= 1;
6434 case IPR_IOASC_SYNC_REQUIRED
:
6436 res
->needs_sync_complete
= 1;
6437 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6439 case IPR_IOASC_MED_DO_NOT_REALLOC
: /* prevent retries */
6440 case IPR_IOASA_IR_DUAL_IOA_DISABLED
:
6442 * exception: do not set DID_PASSTHROUGH on CHECK CONDITION
6443 * so SCSI mid-layer and upper layers handle it accordingly.
6445 if (scsi_cmd
->result
!= SAM_STAT_CHECK_CONDITION
)
6446 scsi_cmd
->result
|= (DID_PASSTHROUGH
<< 16);
6448 case IPR_IOASC_BUS_WAS_RESET
:
6449 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER
:
6451 * Report the bus reset and ask for a retry. The device
6452 * will give CC/UA the next command.
6454 if (!res
->resetting_device
)
6455 scsi_report_bus_reset(ioa_cfg
->host
, scsi_cmd
->device
->channel
);
6456 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6457 if (!ipr_is_naca_model(res
))
6458 res
->needs_sync_complete
= 1;
6460 case IPR_IOASC_HW_DEV_BUS_STATUS
:
6461 scsi_cmd
->result
|= IPR_IOASC_SENSE_STATUS(ioasc
);
6462 if (IPR_IOASC_SENSE_STATUS(ioasc
) == SAM_STAT_CHECK_CONDITION
) {
6463 if (!ipr_get_autosense(ipr_cmd
)) {
6464 if (!ipr_is_naca_model(res
)) {
6465 ipr_erp_cancel_all(ipr_cmd
);
6470 if (!ipr_is_naca_model(res
))
6471 res
->needs_sync_complete
= 1;
6473 case IPR_IOASC_NR_INIT_CMD_REQUIRED
:
6475 case IPR_IOASC_IR_NON_OPTIMIZED
:
6476 if (res
->raw_mode
) {
6478 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6480 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6483 if (IPR_IOASC_SENSE_KEY(ioasc
) > RECOVERED_ERROR
)
6484 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6485 if (!ipr_is_vset_device(res
) && !ipr_is_naca_model(res
))
6486 res
->needs_sync_complete
= 1;
6490 scsi_dma_unmap(ipr_cmd
->scsi_cmd
);
6491 scsi_cmd
->scsi_done(scsi_cmd
);
6492 if (ipr_cmd
->eh_comp
)
6493 complete(ipr_cmd
->eh_comp
);
6494 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6498 * ipr_scsi_done - mid-layer done function
6499 * @ipr_cmd: ipr command struct
6501 * This function is invoked by the interrupt handler for
6502 * ops generated by the SCSI mid-layer
6507 static void ipr_scsi_done(struct ipr_cmnd
*ipr_cmd
)
6509 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
6510 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6511 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6512 unsigned long lock_flags
;
6514 scsi_set_resid(scsi_cmd
, be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.residual_data_len
));
6516 if (likely(IPR_IOASC_SENSE_KEY(ioasc
) == 0)) {
6517 scsi_dma_unmap(scsi_cmd
);
6519 spin_lock_irqsave(ipr_cmd
->hrrq
->lock
, lock_flags
);
6520 scsi_cmd
->scsi_done(scsi_cmd
);
6521 if (ipr_cmd
->eh_comp
)
6522 complete(ipr_cmd
->eh_comp
);
6523 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6524 spin_unlock_irqrestore(ipr_cmd
->hrrq
->lock
, lock_flags
);
6526 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
6527 spin_lock(&ipr_cmd
->hrrq
->_lock
);
6528 ipr_erp_start(ioa_cfg
, ipr_cmd
);
6529 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6530 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
6535 * ipr_queuecommand - Queue a mid-layer request
6536 * @shost: scsi host struct
6537 * @scsi_cmd: scsi command struct
6539 * This function queues a request generated by the mid-layer.
6543 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6544 * SCSI_MLQUEUE_HOST_BUSY if host is busy
6546 static int ipr_queuecommand(struct Scsi_Host
*shost
,
6547 struct scsi_cmnd
*scsi_cmd
)
6549 struct ipr_ioa_cfg
*ioa_cfg
;
6550 struct ipr_resource_entry
*res
;
6551 struct ipr_ioarcb
*ioarcb
;
6552 struct ipr_cmnd
*ipr_cmd
;
6553 unsigned long hrrq_flags
, lock_flags
;
6555 struct ipr_hrr_queue
*hrrq
;
6558 ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
6560 scsi_cmd
->result
= (DID_OK
<< 16);
6561 res
= scsi_cmd
->device
->hostdata
;
6563 if (ipr_is_gata(res
) && res
->sata_port
) {
6564 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
6565 rc
= ata_sas_queuecmd(scsi_cmd
, res
->sata_port
->ap
);
6566 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
6570 hrrq_id
= ipr_get_hrrq_index(ioa_cfg
);
6571 hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
6573 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6575 * We are currently blocking all devices due to a host reset
6576 * We have told the host to stop giving us new requests, but
6577 * ERP ops don't count. FIXME
6579 if (unlikely(!hrrq
->allow_cmds
&& !hrrq
->ioa_is_dead
&& !hrrq
->removing_ioa
)) {
6580 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6581 return SCSI_MLQUEUE_HOST_BUSY
;
6585 * FIXME - Create scsi_set_host_offline interface
6586 * and the ioa_is_dead check can be removed
6588 if (unlikely(hrrq
->ioa_is_dead
|| hrrq
->removing_ioa
|| !res
)) {
6589 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6593 ipr_cmd
= __ipr_get_free_ipr_cmnd(hrrq
);
6594 if (ipr_cmd
== NULL
) {
6595 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6596 return SCSI_MLQUEUE_HOST_BUSY
;
6598 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6600 ipr_init_ipr_cmnd(ipr_cmd
, ipr_scsi_done
);
6601 ioarcb
= &ipr_cmd
->ioarcb
;
6603 memcpy(ioarcb
->cmd_pkt
.cdb
, scsi_cmd
->cmnd
, scsi_cmd
->cmd_len
);
6604 ipr_cmd
->scsi_cmd
= scsi_cmd
;
6605 ipr_cmd
->done
= ipr_scsi_eh_done
;
6607 if (ipr_is_gscsi(res
)) {
6608 if (scsi_cmd
->underflow
== 0)
6609 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6611 if (res
->reset_occurred
) {
6612 res
->reset_occurred
= 0;
6613 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_DELAY_AFTER_RST
;
6617 if (ipr_is_gscsi(res
) || ipr_is_vset_device(res
)) {
6618 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_LINK_DESC
;
6620 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_ALIGNED_BFR
;
6621 if (scsi_cmd
->flags
& SCMD_TAGGED
)
6622 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_SIMPLE_TASK
;
6624 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_UNTAGGED_TASK
;
6627 if (scsi_cmd
->cmnd
[0] >= 0xC0 &&
6628 (!ipr_is_gscsi(res
) || scsi_cmd
->cmnd
[0] == IPR_QUERY_RSRC_STATE
)) {
6629 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
6631 if (res
->raw_mode
&& ipr_is_af_dasd_device(res
)) {
6632 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_PIPE
;
6634 if (scsi_cmd
->underflow
== 0)
6635 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6639 rc
= ipr_build_ioadl64(ioa_cfg
, ipr_cmd
);
6641 rc
= ipr_build_ioadl(ioa_cfg
, ipr_cmd
);
6643 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6644 if (unlikely(rc
|| (!hrrq
->allow_cmds
&& !hrrq
->ioa_is_dead
))) {
6645 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_free_q
);
6646 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6648 scsi_dma_unmap(scsi_cmd
);
6649 return SCSI_MLQUEUE_HOST_BUSY
;
6652 if (unlikely(hrrq
->ioa_is_dead
)) {
6653 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_free_q
);
6654 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6655 scsi_dma_unmap(scsi_cmd
);
6659 ioarcb
->res_handle
= res
->res_handle
;
6660 if (res
->needs_sync_complete
) {
6661 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_SYNC_COMPLETE
;
6662 res
->needs_sync_complete
= 0;
6664 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_pending_q
);
6665 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, IPR_GET_RES_PHYS_LOC(res
));
6666 ipr_send_command(ipr_cmd
);
6667 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6671 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6672 memset(scsi_cmd
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
6673 scsi_cmd
->result
= (DID_NO_CONNECT
<< 16);
6674 scsi_cmd
->scsi_done(scsi_cmd
);
6675 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6680 * ipr_ioctl - IOCTL handler
6681 * @sdev: scsi device struct
6686 * 0 on success / other on failure
6688 static int ipr_ioctl(struct scsi_device
*sdev
, unsigned int cmd
,
6691 struct ipr_resource_entry
*res
;
6693 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
6694 if (res
&& ipr_is_gata(res
)) {
6695 if (cmd
== HDIO_GET_IDENTITY
)
6697 return ata_sas_scsi_ioctl(res
->sata_port
->ap
, sdev
, cmd
, arg
);
6704 * ipr_info - Get information about the card/driver
6705 * @scsi_host: scsi host struct
6708 * pointer to buffer with description string
6710 static const char *ipr_ioa_info(struct Scsi_Host
*host
)
6712 static char buffer
[512];
6713 struct ipr_ioa_cfg
*ioa_cfg
;
6714 unsigned long lock_flags
= 0;
6716 ioa_cfg
= (struct ipr_ioa_cfg
*) host
->hostdata
;
6718 spin_lock_irqsave(host
->host_lock
, lock_flags
);
6719 sprintf(buffer
, "IBM %X Storage Adapter", ioa_cfg
->type
);
6720 spin_unlock_irqrestore(host
->host_lock
, lock_flags
);
6725 static struct scsi_host_template driver_template
= {
6726 .module
= THIS_MODULE
,
6728 .info
= ipr_ioa_info
,
6730 #ifdef CONFIG_COMPAT
6731 .compat_ioctl
= ipr_ioctl
,
6733 .queuecommand
= ipr_queuecommand
,
6734 .eh_abort_handler
= ipr_eh_abort
,
6735 .eh_device_reset_handler
= ipr_eh_dev_reset
,
6736 .eh_host_reset_handler
= ipr_eh_host_reset
,
6737 .slave_alloc
= ipr_slave_alloc
,
6738 .slave_configure
= ipr_slave_configure
,
6739 .slave_destroy
= ipr_slave_destroy
,
6740 .scan_finished
= ipr_scan_finished
,
6741 .target_alloc
= ipr_target_alloc
,
6742 .target_destroy
= ipr_target_destroy
,
6743 .change_queue_depth
= ipr_change_queue_depth
,
6744 .bios_param
= ipr_biosparam
,
6745 .can_queue
= IPR_MAX_COMMANDS
,
6747 .sg_tablesize
= IPR_MAX_SGLIST
,
6748 .max_sectors
= IPR_IOA_MAX_SECTORS
,
6749 .cmd_per_lun
= IPR_MAX_CMD_PER_LUN
,
6750 .shost_attrs
= ipr_ioa_attrs
,
6751 .sdev_attrs
= ipr_dev_attrs
,
6752 .proc_name
= IPR_NAME
,
6756 * ipr_ata_phy_reset - libata phy_reset handler
6757 * @ap: ata port to reset
6760 static void ipr_ata_phy_reset(struct ata_port
*ap
)
6762 unsigned long flags
;
6763 struct ipr_sata_port
*sata_port
= ap
->private_data
;
6764 struct ipr_resource_entry
*res
= sata_port
->res
;
6765 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6769 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6770 while (ioa_cfg
->in_reset_reload
) {
6771 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6772 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
6773 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6776 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
)
6779 rc
= ipr_device_reset(ioa_cfg
, res
);
6782 ap
->link
.device
[0].class = ATA_DEV_NONE
;
6786 ap
->link
.device
[0].class = res
->ata_class
;
6787 if (ap
->link
.device
[0].class == ATA_DEV_UNKNOWN
)
6788 ap
->link
.device
[0].class = ATA_DEV_NONE
;
6791 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6796 * ipr_ata_post_internal - Cleanup after an internal command
6797 * @qc: ATA queued command
6802 static void ipr_ata_post_internal(struct ata_queued_cmd
*qc
)
6804 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
6805 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6806 struct ipr_cmnd
*ipr_cmd
;
6807 struct ipr_hrr_queue
*hrrq
;
6808 unsigned long flags
;
6810 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6811 while (ioa_cfg
->in_reset_reload
) {
6812 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6813 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
6814 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6817 for_each_hrrq(hrrq
, ioa_cfg
) {
6818 spin_lock(&hrrq
->_lock
);
6819 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
6820 if (ipr_cmd
->qc
== qc
) {
6821 ipr_device_reset(ioa_cfg
, sata_port
->res
);
6825 spin_unlock(&hrrq
->_lock
);
6827 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6831 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6832 * @regs: destination
6833 * @tf: source ATA taskfile
6838 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs
*regs
,
6839 struct ata_taskfile
*tf
)
6841 regs
->feature
= tf
->feature
;
6842 regs
->nsect
= tf
->nsect
;
6843 regs
->lbal
= tf
->lbal
;
6844 regs
->lbam
= tf
->lbam
;
6845 regs
->lbah
= tf
->lbah
;
6846 regs
->device
= tf
->device
;
6847 regs
->command
= tf
->command
;
6848 regs
->hob_feature
= tf
->hob_feature
;
6849 regs
->hob_nsect
= tf
->hob_nsect
;
6850 regs
->hob_lbal
= tf
->hob_lbal
;
6851 regs
->hob_lbam
= tf
->hob_lbam
;
6852 regs
->hob_lbah
= tf
->hob_lbah
;
6853 regs
->ctl
= tf
->ctl
;
6857 * ipr_sata_done - done function for SATA commands
6858 * @ipr_cmd: ipr command struct
6860 * This function is invoked by the interrupt handler for
6861 * ops generated by the SCSI mid-layer to SATA devices
6866 static void ipr_sata_done(struct ipr_cmnd
*ipr_cmd
)
6868 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
6869 struct ata_queued_cmd
*qc
= ipr_cmd
->qc
;
6870 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
6871 struct ipr_resource_entry
*res
= sata_port
->res
;
6872 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6874 spin_lock(&ipr_cmd
->hrrq
->_lock
);
6875 if (ipr_cmd
->ioa_cfg
->sis64
)
6876 memcpy(&sata_port
->ioasa
, &ipr_cmd
->s
.ioasa64
.u
.gata
,
6877 sizeof(struct ipr_ioasa_gata
));
6879 memcpy(&sata_port
->ioasa
, &ipr_cmd
->s
.ioasa
.u
.gata
,
6880 sizeof(struct ipr_ioasa_gata
));
6881 ipr_dump_ioasa(ioa_cfg
, ipr_cmd
, res
);
6883 if (be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc_specific
) & IPR_ATA_DEVICE_WAS_RESET
)
6884 scsi_report_device_reset(ioa_cfg
->host
, res
->bus
, res
->target
);
6886 if (IPR_IOASC_SENSE_KEY(ioasc
) > RECOVERED_ERROR
)
6887 qc
->err_mask
|= __ac_err_mask(sata_port
->ioasa
.status
);
6889 qc
->err_mask
|= ac_err_mask(sata_port
->ioasa
.status
);
6890 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6891 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6892 ata_qc_complete(qc
);
6896 * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6897 * @ipr_cmd: ipr command struct
6898 * @qc: ATA queued command
6901 static void ipr_build_ata_ioadl64(struct ipr_cmnd
*ipr_cmd
,
6902 struct ata_queued_cmd
*qc
)
6904 u32 ioadl_flags
= 0;
6905 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
6906 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ata_ioadl
.ioadl64
;
6907 struct ipr_ioadl64_desc
*last_ioadl64
= NULL
;
6908 int len
= qc
->nbytes
;
6909 struct scatterlist
*sg
;
6911 dma_addr_t dma_addr
= ipr_cmd
->dma_addr
;
6916 if (qc
->dma_dir
== DMA_TO_DEVICE
) {
6917 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
6918 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
6919 } else if (qc
->dma_dir
== DMA_FROM_DEVICE
)
6920 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
6922 ioarcb
->data_transfer_length
= cpu_to_be32(len
);
6924 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
6925 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
6926 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ata_ioadl
.ioadl64
));
6928 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
) {
6929 ioadl64
->flags
= cpu_to_be32(ioadl_flags
);
6930 ioadl64
->data_len
= cpu_to_be32(sg_dma_len(sg
));
6931 ioadl64
->address
= cpu_to_be64(sg_dma_address(sg
));
6933 last_ioadl64
= ioadl64
;
6937 if (likely(last_ioadl64
))
6938 last_ioadl64
->flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
6942 * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6943 * @ipr_cmd: ipr command struct
6944 * @qc: ATA queued command
6947 static void ipr_build_ata_ioadl(struct ipr_cmnd
*ipr_cmd
,
6948 struct ata_queued_cmd
*qc
)
6950 u32 ioadl_flags
= 0;
6951 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
6952 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
6953 struct ipr_ioadl_desc
*last_ioadl
= NULL
;
6954 int len
= qc
->nbytes
;
6955 struct scatterlist
*sg
;
6961 if (qc
->dma_dir
== DMA_TO_DEVICE
) {
6962 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
6963 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
6964 ioarcb
->data_transfer_length
= cpu_to_be32(len
);
6966 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
6967 } else if (qc
->dma_dir
== DMA_FROM_DEVICE
) {
6968 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
6969 ioarcb
->read_data_transfer_length
= cpu_to_be32(len
);
6970 ioarcb
->read_ioadl_len
=
6971 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
6974 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
) {
6975 ioadl
->flags_and_data_len
= cpu_to_be32(ioadl_flags
| sg_dma_len(sg
));
6976 ioadl
->address
= cpu_to_be32(sg_dma_address(sg
));
6982 if (likely(last_ioadl
))
6983 last_ioadl
->flags_and_data_len
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
6987 * ipr_qc_defer - Get a free ipr_cmd
6988 * @qc: queued command
6993 static int ipr_qc_defer(struct ata_queued_cmd
*qc
)
6995 struct ata_port
*ap
= qc
->ap
;
6996 struct ipr_sata_port
*sata_port
= ap
->private_data
;
6997 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6998 struct ipr_cmnd
*ipr_cmd
;
6999 struct ipr_hrr_queue
*hrrq
;
7002 hrrq_id
= ipr_get_hrrq_index(ioa_cfg
);
7003 hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
7005 qc
->lldd_task
= NULL
;
7006 spin_lock(&hrrq
->_lock
);
7007 if (unlikely(hrrq
->ioa_is_dead
)) {
7008 spin_unlock(&hrrq
->_lock
);
7012 if (unlikely(!hrrq
->allow_cmds
)) {
7013 spin_unlock(&hrrq
->_lock
);
7014 return ATA_DEFER_LINK
;
7017 ipr_cmd
= __ipr_get_free_ipr_cmnd(hrrq
);
7018 if (ipr_cmd
== NULL
) {
7019 spin_unlock(&hrrq
->_lock
);
7020 return ATA_DEFER_LINK
;
7023 qc
->lldd_task
= ipr_cmd
;
7024 spin_unlock(&hrrq
->_lock
);
7029 * ipr_qc_issue - Issue a SATA qc to a device
7030 * @qc: queued command
7035 static unsigned int ipr_qc_issue(struct ata_queued_cmd
*qc
)
7037 struct ata_port
*ap
= qc
->ap
;
7038 struct ipr_sata_port
*sata_port
= ap
->private_data
;
7039 struct ipr_resource_entry
*res
= sata_port
->res
;
7040 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
7041 struct ipr_cmnd
*ipr_cmd
;
7042 struct ipr_ioarcb
*ioarcb
;
7043 struct ipr_ioarcb_ata_regs
*regs
;
7045 if (qc
->lldd_task
== NULL
)
7048 ipr_cmd
= qc
->lldd_task
;
7049 if (ipr_cmd
== NULL
)
7050 return AC_ERR_SYSTEM
;
7052 qc
->lldd_task
= NULL
;
7053 spin_lock(&ipr_cmd
->hrrq
->_lock
);
7054 if (unlikely(!ipr_cmd
->hrrq
->allow_cmds
||
7055 ipr_cmd
->hrrq
->ioa_is_dead
)) {
7056 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7057 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
7058 return AC_ERR_SYSTEM
;
7061 ipr_init_ipr_cmnd(ipr_cmd
, ipr_lock_and_done
);
7062 ioarcb
= &ipr_cmd
->ioarcb
;
7064 if (ioa_cfg
->sis64
) {
7065 regs
= &ipr_cmd
->i
.ata_ioadl
.regs
;
7066 ioarcb
->add_cmd_parms_offset
= cpu_to_be16(sizeof(*ioarcb
));
7068 regs
= &ioarcb
->u
.add_data
.u
.regs
;
7070 memset(regs
, 0, sizeof(*regs
));
7071 ioarcb
->add_cmd_parms_len
= cpu_to_be16(sizeof(*regs
));
7073 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
7075 ipr_cmd
->done
= ipr_sata_done
;
7076 ipr_cmd
->ioarcb
.res_handle
= res
->res_handle
;
7077 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_ATA_PASSTHRU
;
7078 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_LINK_DESC
;
7079 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
7080 ipr_cmd
->dma_use_sg
= qc
->n_elem
;
7083 ipr_build_ata_ioadl64(ipr_cmd
, qc
);
7085 ipr_build_ata_ioadl(ipr_cmd
, qc
);
7087 regs
->flags
|= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION
;
7088 ipr_copy_sata_tf(regs
, &qc
->tf
);
7089 memcpy(ioarcb
->cmd_pkt
.cdb
, qc
->cdb
, IPR_MAX_CDB_LEN
);
7090 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, IPR_GET_RES_PHYS_LOC(res
));
7092 switch (qc
->tf
.protocol
) {
7093 case ATA_PROT_NODATA
:
7098 regs
->flags
|= IPR_ATA_FLAG_XFER_TYPE_DMA
;
7101 case ATAPI_PROT_PIO
:
7102 case ATAPI_PROT_NODATA
:
7103 regs
->flags
|= IPR_ATA_FLAG_PACKET_CMD
;
7106 case ATAPI_PROT_DMA
:
7107 regs
->flags
|= IPR_ATA_FLAG_PACKET_CMD
;
7108 regs
->flags
|= IPR_ATA_FLAG_XFER_TYPE_DMA
;
7113 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
7114 return AC_ERR_INVALID
;
7117 ipr_send_command(ipr_cmd
);
7118 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
7124 * ipr_qc_fill_rtf - Read result TF
7125 * @qc: ATA queued command
7130 static bool ipr_qc_fill_rtf(struct ata_queued_cmd
*qc
)
7132 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
7133 struct ipr_ioasa_gata
*g
= &sata_port
->ioasa
;
7134 struct ata_taskfile
*tf
= &qc
->result_tf
;
7136 tf
->feature
= g
->error
;
7137 tf
->nsect
= g
->nsect
;
7141 tf
->device
= g
->device
;
7142 tf
->command
= g
->status
;
7143 tf
->hob_nsect
= g
->hob_nsect
;
7144 tf
->hob_lbal
= g
->hob_lbal
;
7145 tf
->hob_lbam
= g
->hob_lbam
;
7146 tf
->hob_lbah
= g
->hob_lbah
;
7151 static struct ata_port_operations ipr_sata_ops
= {
7152 .phy_reset
= ipr_ata_phy_reset
,
7153 .hardreset
= ipr_sata_reset
,
7154 .post_internal_cmd
= ipr_ata_post_internal
,
7155 .qc_prep
= ata_noop_qc_prep
,
7156 .qc_defer
= ipr_qc_defer
,
7157 .qc_issue
= ipr_qc_issue
,
7158 .qc_fill_rtf
= ipr_qc_fill_rtf
,
7159 .port_start
= ata_sas_port_start
,
7160 .port_stop
= ata_sas_port_stop
7163 static struct ata_port_info sata_port_info
= {
7164 .flags
= ATA_FLAG_SATA
| ATA_FLAG_PIO_DMA
|
7166 .pio_mask
= ATA_PIO4_ONLY
,
7167 .mwdma_mask
= ATA_MWDMA2
,
7168 .udma_mask
= ATA_UDMA6
,
7169 .port_ops
= &ipr_sata_ops
7172 #ifdef CONFIG_PPC_PSERIES
7173 static const u16 ipr_blocked_processors
[] = {
7185 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
7186 * @ioa_cfg: ioa cfg struct
7188 * Adapters that use Gemstone revision < 3.1 do not work reliably on
7189 * certain pSeries hardware. This function determines if the given
7190 * adapter is in one of these confgurations or not.
7193 * 1 if adapter is not supported / 0 if adapter is supported
7195 static int ipr_invalid_adapter(struct ipr_ioa_cfg
*ioa_cfg
)
7199 if ((ioa_cfg
->type
== 0x5702) && (ioa_cfg
->pdev
->revision
< 4)) {
7200 for (i
= 0; i
< ARRAY_SIZE(ipr_blocked_processors
); i
++) {
7201 if (pvr_version_is(ipr_blocked_processors
[i
]))
7208 #define ipr_invalid_adapter(ioa_cfg) 0
7212 * ipr_ioa_bringdown_done - IOA bring down completion.
7213 * @ipr_cmd: ipr command struct
7215 * This function processes the completion of an adapter bring down.
7216 * It wakes any reset sleepers.
7221 static int ipr_ioa_bringdown_done(struct ipr_cmnd
*ipr_cmd
)
7223 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7227 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
) {
7229 ioa_cfg
->scsi_unblock
= 1;
7230 schedule_work(&ioa_cfg
->work_q
);
7233 ioa_cfg
->in_reset_reload
= 0;
7234 ioa_cfg
->reset_retries
= 0;
7235 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
7236 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
7237 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 1;
7238 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
7242 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7243 wake_up_all(&ioa_cfg
->reset_wait_q
);
7246 return IPR_RC_JOB_RETURN
;
7250 * ipr_ioa_reset_done - IOA reset completion.
7251 * @ipr_cmd: ipr command struct
7253 * This function processes the completion of an adapter reset.
7254 * It schedules any necessary mid-layer add/removes and
7255 * wakes any reset sleepers.
7260 static int ipr_ioa_reset_done(struct ipr_cmnd
*ipr_cmd
)
7262 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7263 struct ipr_resource_entry
*res
;
7267 ioa_cfg
->in_reset_reload
= 0;
7268 for (j
= 0; j
< ioa_cfg
->hrrq_num
; j
++) {
7269 spin_lock(&ioa_cfg
->hrrq
[j
]._lock
);
7270 ioa_cfg
->hrrq
[j
].allow_cmds
= 1;
7271 spin_unlock(&ioa_cfg
->hrrq
[j
]._lock
);
7274 ioa_cfg
->reset_cmd
= NULL
;
7275 ioa_cfg
->doorbell
|= IPR_RUNTIME_RESET
;
7277 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
7278 if (res
->add_to_ml
|| res
->del_from_ml
) {
7283 schedule_work(&ioa_cfg
->work_q
);
7285 for (j
= 0; j
< IPR_NUM_HCAMS
; j
++) {
7286 list_del_init(&ioa_cfg
->hostrcb
[j
]->queue
);
7287 if (j
< IPR_NUM_LOG_HCAMS
)
7288 ipr_send_hcam(ioa_cfg
,
7289 IPR_HCAM_CDB_OP_CODE_LOG_DATA
,
7290 ioa_cfg
->hostrcb
[j
]);
7292 ipr_send_hcam(ioa_cfg
,
7293 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
,
7294 ioa_cfg
->hostrcb
[j
]);
7297 scsi_report_bus_reset(ioa_cfg
->host
, IPR_VSET_BUS
);
7298 dev_info(&ioa_cfg
->pdev
->dev
, "IOA initialized.\n");
7300 ioa_cfg
->reset_retries
= 0;
7301 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7302 wake_up_all(&ioa_cfg
->reset_wait_q
);
7304 ioa_cfg
->scsi_unblock
= 1;
7305 schedule_work(&ioa_cfg
->work_q
);
7307 return IPR_RC_JOB_RETURN
;
7311 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7312 * @supported_dev: supported device struct
7313 * @vpids: vendor product id struct
7318 static void ipr_set_sup_dev_dflt(struct ipr_supported_device
*supported_dev
,
7319 struct ipr_std_inq_vpids
*vpids
)
7321 memset(supported_dev
, 0, sizeof(struct ipr_supported_device
));
7322 memcpy(&supported_dev
->vpids
, vpids
, sizeof(struct ipr_std_inq_vpids
));
7323 supported_dev
->num_records
= 1;
7324 supported_dev
->data_length
=
7325 cpu_to_be16(sizeof(struct ipr_supported_device
));
7326 supported_dev
->reserved
= 0;
7330 * ipr_set_supported_devs - Send Set Supported Devices for a device
7331 * @ipr_cmd: ipr command struct
7333 * This function sends a Set Supported Devices to the adapter
7336 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7338 static int ipr_set_supported_devs(struct ipr_cmnd
*ipr_cmd
)
7340 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7341 struct ipr_supported_device
*supp_dev
= &ioa_cfg
->vpd_cbs
->supp_dev
;
7342 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7343 struct ipr_resource_entry
*res
= ipr_cmd
->u
.res
;
7345 ipr_cmd
->job_step
= ipr_ioa_reset_done
;
7347 list_for_each_entry_continue(res
, &ioa_cfg
->used_res_q
, queue
) {
7348 if (!ipr_is_scsi_disk(res
))
7351 ipr_cmd
->u
.res
= res
;
7352 ipr_set_sup_dev_dflt(supp_dev
, &res
->std_inq_data
.vpids
);
7354 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7355 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
7356 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7358 ioarcb
->cmd_pkt
.cdb
[0] = IPR_SET_SUPPORTED_DEVICES
;
7359 ioarcb
->cmd_pkt
.cdb
[1] = IPR_SET_ALL_SUPPORTED_DEVICES
;
7360 ioarcb
->cmd_pkt
.cdb
[7] = (sizeof(struct ipr_supported_device
) >> 8) & 0xff;
7361 ioarcb
->cmd_pkt
.cdb
[8] = sizeof(struct ipr_supported_device
) & 0xff;
7363 ipr_init_ioadl(ipr_cmd
,
7364 ioa_cfg
->vpd_cbs_dma
+
7365 offsetof(struct ipr_misc_cbs
, supp_dev
),
7366 sizeof(struct ipr_supported_device
),
7367 IPR_IOADL_FLAGS_WRITE_LAST
);
7369 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
7370 IPR_SET_SUP_DEVICE_TIMEOUT
);
7372 if (!ioa_cfg
->sis64
)
7373 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7375 return IPR_RC_JOB_RETURN
;
7379 return IPR_RC_JOB_CONTINUE
;
7383 * ipr_get_mode_page - Locate specified mode page
7384 * @mode_pages: mode page buffer
7385 * @page_code: page code to find
7386 * @len: minimum required length for mode page
7389 * pointer to mode page / NULL on failure
7391 static void *ipr_get_mode_page(struct ipr_mode_pages
*mode_pages
,
7392 u32 page_code
, u32 len
)
7394 struct ipr_mode_page_hdr
*mode_hdr
;
7398 if (!mode_pages
|| (mode_pages
->hdr
.length
== 0))
7401 length
= (mode_pages
->hdr
.length
+ 1) - 4 - mode_pages
->hdr
.block_desc_len
;
7402 mode_hdr
= (struct ipr_mode_page_hdr
*)
7403 (mode_pages
->data
+ mode_pages
->hdr
.block_desc_len
);
7406 if (IPR_GET_MODE_PAGE_CODE(mode_hdr
) == page_code
) {
7407 if (mode_hdr
->page_length
>= (len
- sizeof(struct ipr_mode_page_hdr
)))
7411 page_length
= (sizeof(struct ipr_mode_page_hdr
) +
7412 mode_hdr
->page_length
);
7413 length
-= page_length
;
7414 mode_hdr
= (struct ipr_mode_page_hdr
*)
7415 ((unsigned long)mode_hdr
+ page_length
);
7422 * ipr_check_term_power - Check for term power errors
7423 * @ioa_cfg: ioa config struct
7424 * @mode_pages: IOAFP mode pages buffer
7426 * Check the IOAFP's mode page 28 for term power errors
7431 static void ipr_check_term_power(struct ipr_ioa_cfg
*ioa_cfg
,
7432 struct ipr_mode_pages
*mode_pages
)
7436 struct ipr_dev_bus_entry
*bus
;
7437 struct ipr_mode_page28
*mode_page
;
7439 mode_page
= ipr_get_mode_page(mode_pages
, 0x28,
7440 sizeof(struct ipr_mode_page28
));
7442 entry_length
= mode_page
->entry_length
;
7444 bus
= mode_page
->bus
;
7446 for (i
= 0; i
< mode_page
->num_entries
; i
++) {
7447 if (bus
->flags
& IPR_SCSI_ATTR_NO_TERM_PWR
) {
7448 dev_err(&ioa_cfg
->pdev
->dev
,
7449 "Term power is absent on scsi bus %d\n",
7453 bus
= (struct ipr_dev_bus_entry
*)((char *)bus
+ entry_length
);
7458 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7459 * @ioa_cfg: ioa config struct
7461 * Looks through the config table checking for SES devices. If
7462 * the SES device is in the SES table indicating a maximum SCSI
7463 * bus speed, the speed is limited for the bus.
7468 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg
*ioa_cfg
)
7473 for (i
= 0; i
< IPR_MAX_NUM_BUSES
; i
++) {
7474 max_xfer_rate
= ipr_get_max_scsi_speed(ioa_cfg
, i
,
7475 ioa_cfg
->bus_attr
[i
].bus_width
);
7477 if (max_xfer_rate
< ioa_cfg
->bus_attr
[i
].max_xfer_rate
)
7478 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= max_xfer_rate
;
7483 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7484 * @ioa_cfg: ioa config struct
7485 * @mode_pages: mode page 28 buffer
7487 * Updates mode page 28 based on driver configuration
7492 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg
*ioa_cfg
,
7493 struct ipr_mode_pages
*mode_pages
)
7495 int i
, entry_length
;
7496 struct ipr_dev_bus_entry
*bus
;
7497 struct ipr_bus_attributes
*bus_attr
;
7498 struct ipr_mode_page28
*mode_page
;
7500 mode_page
= ipr_get_mode_page(mode_pages
, 0x28,
7501 sizeof(struct ipr_mode_page28
));
7503 entry_length
= mode_page
->entry_length
;
7505 /* Loop for each device bus entry */
7506 for (i
= 0, bus
= mode_page
->bus
;
7507 i
< mode_page
->num_entries
;
7508 i
++, bus
= (struct ipr_dev_bus_entry
*)((u8
*)bus
+ entry_length
)) {
7509 if (bus
->res_addr
.bus
> IPR_MAX_NUM_BUSES
) {
7510 dev_err(&ioa_cfg
->pdev
->dev
,
7511 "Invalid resource address reported: 0x%08X\n",
7512 IPR_GET_PHYS_LOC(bus
->res_addr
));
7516 bus_attr
= &ioa_cfg
->bus_attr
[i
];
7517 bus
->extended_reset_delay
= IPR_EXTENDED_RESET_DELAY
;
7518 bus
->bus_width
= bus_attr
->bus_width
;
7519 bus
->max_xfer_rate
= cpu_to_be32(bus_attr
->max_xfer_rate
);
7520 bus
->flags
&= ~IPR_SCSI_ATTR_QAS_MASK
;
7521 if (bus_attr
->qas_enabled
)
7522 bus
->flags
|= IPR_SCSI_ATTR_ENABLE_QAS
;
7524 bus
->flags
|= IPR_SCSI_ATTR_DISABLE_QAS
;
7529 * ipr_build_mode_select - Build a mode select command
7530 * @ipr_cmd: ipr command struct
7531 * @res_handle: resource handle to send command to
7532 * @parm: Byte 2 of Mode Sense command
7533 * @dma_addr: DMA buffer address
7534 * @xfer_len: data transfer length
7539 static void ipr_build_mode_select(struct ipr_cmnd
*ipr_cmd
,
7540 __be32 res_handle
, u8 parm
,
7541 dma_addr_t dma_addr
, u8 xfer_len
)
7543 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7545 ioarcb
->res_handle
= res_handle
;
7546 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7547 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
7548 ioarcb
->cmd_pkt
.cdb
[0] = MODE_SELECT
;
7549 ioarcb
->cmd_pkt
.cdb
[1] = parm
;
7550 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7552 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_WRITE_LAST
);
7556 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7557 * @ipr_cmd: ipr command struct
7559 * This function sets up the SCSI bus attributes and sends
7560 * a Mode Select for Page 28 to activate them.
7565 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd
*ipr_cmd
)
7567 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7568 struct ipr_mode_pages
*mode_pages
= &ioa_cfg
->vpd_cbs
->mode_pages
;
7572 ipr_scsi_bus_speed_limit(ioa_cfg
);
7573 ipr_check_term_power(ioa_cfg
, mode_pages
);
7574 ipr_modify_ioafp_mode_page_28(ioa_cfg
, mode_pages
);
7575 length
= mode_pages
->hdr
.length
+ 1;
7576 mode_pages
->hdr
.length
= 0;
7578 ipr_build_mode_select(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
), 0x11,
7579 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, mode_pages
),
7582 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7583 ipr_cmd
->u
.res
= list_entry(ioa_cfg
->used_res_q
.next
,
7584 struct ipr_resource_entry
, queue
);
7585 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7588 return IPR_RC_JOB_RETURN
;
7592 * ipr_build_mode_sense - Builds a mode sense command
7593 * @ipr_cmd: ipr command struct
7594 * @res: resource entry struct
7595 * @parm: Byte 2 of mode sense command
7596 * @dma_addr: DMA address of mode sense buffer
7597 * @xfer_len: Size of DMA buffer
7602 static void ipr_build_mode_sense(struct ipr_cmnd
*ipr_cmd
,
7604 u8 parm
, dma_addr_t dma_addr
, u8 xfer_len
)
7606 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7608 ioarcb
->res_handle
= res_handle
;
7609 ioarcb
->cmd_pkt
.cdb
[0] = MODE_SENSE
;
7610 ioarcb
->cmd_pkt
.cdb
[2] = parm
;
7611 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7612 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7614 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_READ_LAST
);
7618 * ipr_reset_cmd_failed - Handle failure of IOA reset command
7619 * @ipr_cmd: ipr command struct
7621 * This function handles the failure of an IOA bringup command.
7626 static int ipr_reset_cmd_failed(struct ipr_cmnd
*ipr_cmd
)
7628 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7629 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7631 dev_err(&ioa_cfg
->pdev
->dev
,
7632 "0x%02X failed with IOASC: 0x%08X\n",
7633 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0], ioasc
);
7635 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
7636 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7637 return IPR_RC_JOB_RETURN
;
7641 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7642 * @ipr_cmd: ipr command struct
7644 * This function handles the failure of a Mode Sense to the IOAFP.
7645 * Some adapters do not handle all mode pages.
7648 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7650 static int ipr_reset_mode_sense_failed(struct ipr_cmnd
*ipr_cmd
)
7652 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7653 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7655 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
) {
7656 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7657 ipr_cmd
->u
.res
= list_entry(ioa_cfg
->used_res_q
.next
,
7658 struct ipr_resource_entry
, queue
);
7659 return IPR_RC_JOB_CONTINUE
;
7662 return ipr_reset_cmd_failed(ipr_cmd
);
7666 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7667 * @ipr_cmd: ipr command struct
7669 * This function send a Page 28 mode sense to the IOA to
7670 * retrieve SCSI bus attributes.
7675 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd
*ipr_cmd
)
7677 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7680 ipr_build_mode_sense(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
),
7681 0x28, ioa_cfg
->vpd_cbs_dma
+
7682 offsetof(struct ipr_misc_cbs
, mode_pages
),
7683 sizeof(struct ipr_mode_pages
));
7685 ipr_cmd
->job_step
= ipr_ioafp_mode_select_page28
;
7686 ipr_cmd
->job_step_failed
= ipr_reset_mode_sense_failed
;
7688 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7691 return IPR_RC_JOB_RETURN
;
7695 * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7696 * @ipr_cmd: ipr command struct
7698 * This function enables dual IOA RAID support if possible.
7703 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd
*ipr_cmd
)
7705 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7706 struct ipr_mode_pages
*mode_pages
= &ioa_cfg
->vpd_cbs
->mode_pages
;
7707 struct ipr_mode_page24
*mode_page
;
7711 mode_page
= ipr_get_mode_page(mode_pages
, 0x24,
7712 sizeof(struct ipr_mode_page24
));
7715 mode_page
->flags
|= IPR_ENABLE_DUAL_IOA_AF
;
7717 length
= mode_pages
->hdr
.length
+ 1;
7718 mode_pages
->hdr
.length
= 0;
7720 ipr_build_mode_select(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
), 0x11,
7721 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, mode_pages
),
7724 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7725 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7728 return IPR_RC_JOB_RETURN
;
7732 * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7733 * @ipr_cmd: ipr command struct
7735 * This function handles the failure of a Mode Sense to the IOAFP.
7736 * Some adapters do not handle all mode pages.
7739 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7741 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd
*ipr_cmd
)
7743 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7745 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
) {
7746 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7747 return IPR_RC_JOB_CONTINUE
;
7750 return ipr_reset_cmd_failed(ipr_cmd
);
7754 * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7755 * @ipr_cmd: ipr command struct
7757 * This function send a mode sense to the IOA to retrieve
7758 * the IOA Advanced Function Control mode page.
7763 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd
*ipr_cmd
)
7765 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7768 ipr_build_mode_sense(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
),
7769 0x24, ioa_cfg
->vpd_cbs_dma
+
7770 offsetof(struct ipr_misc_cbs
, mode_pages
),
7771 sizeof(struct ipr_mode_pages
));
7773 ipr_cmd
->job_step
= ipr_ioafp_mode_select_page24
;
7774 ipr_cmd
->job_step_failed
= ipr_reset_mode_sense_page24_failed
;
7776 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7779 return IPR_RC_JOB_RETURN
;
7783 * ipr_init_res_table - Initialize the resource table
7784 * @ipr_cmd: ipr command struct
7786 * This function looks through the existing resource table, comparing
7787 * it with the config table. This function will take care of old/new
7788 * devices and schedule adding/removing them from the mid-layer
7792 * IPR_RC_JOB_CONTINUE
7794 static int ipr_init_res_table(struct ipr_cmnd
*ipr_cmd
)
7796 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7797 struct ipr_resource_entry
*res
, *temp
;
7798 struct ipr_config_table_entry_wrapper cfgtew
;
7799 int entries
, found
, flag
, i
;
7804 flag
= ioa_cfg
->u
.cfg_table64
->hdr64
.flags
;
7806 flag
= ioa_cfg
->u
.cfg_table
->hdr
.flags
;
7808 if (flag
& IPR_UCODE_DOWNLOAD_REQ
)
7809 dev_err(&ioa_cfg
->pdev
->dev
, "Microcode download required\n");
7811 list_for_each_entry_safe(res
, temp
, &ioa_cfg
->used_res_q
, queue
)
7812 list_move_tail(&res
->queue
, &old_res
);
7815 entries
= be16_to_cpu(ioa_cfg
->u
.cfg_table64
->hdr64
.num_entries
);
7817 entries
= ioa_cfg
->u
.cfg_table
->hdr
.num_entries
;
7819 for (i
= 0; i
< entries
; i
++) {
7821 cfgtew
.u
.cfgte64
= &ioa_cfg
->u
.cfg_table64
->dev
[i
];
7823 cfgtew
.u
.cfgte
= &ioa_cfg
->u
.cfg_table
->dev
[i
];
7826 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7827 if (ipr_is_same_device(res
, &cfgtew
)) {
7828 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7835 if (list_empty(&ioa_cfg
->free_res_q
)) {
7836 dev_err(&ioa_cfg
->pdev
->dev
, "Too many devices attached\n");
7841 res
= list_entry(ioa_cfg
->free_res_q
.next
,
7842 struct ipr_resource_entry
, queue
);
7843 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7844 ipr_init_res_entry(res
, &cfgtew
);
7846 } else if (res
->sdev
&& (ipr_is_vset_device(res
) || ipr_is_scsi_disk(res
)))
7847 res
->sdev
->allow_restart
= 1;
7850 ipr_update_res_entry(res
, &cfgtew
);
7853 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7855 res
->del_from_ml
= 1;
7856 res
->res_handle
= IPR_INVALID_RES_HANDLE
;
7857 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7861 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7862 ipr_clear_res_target(res
);
7863 list_move_tail(&res
->queue
, &ioa_cfg
->free_res_q
);
7866 if (ioa_cfg
->dual_raid
&& ipr_dual_ioa_raid
)
7867 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page24
;
7869 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7872 return IPR_RC_JOB_CONTINUE
;
7876 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7877 * @ipr_cmd: ipr command struct
7879 * This function sends a Query IOA Configuration command
7880 * to the adapter to retrieve the IOA configuration table.
7885 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd
*ipr_cmd
)
7887 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7888 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7889 struct ipr_inquiry_page3
*ucode_vpd
= &ioa_cfg
->vpd_cbs
->page3_data
;
7890 struct ipr_inquiry_cap
*cap
= &ioa_cfg
->vpd_cbs
->cap
;
7893 if (cap
->cap
& IPR_CAP_DUAL_IOA_RAID
)
7894 ioa_cfg
->dual_raid
= 1;
7895 dev_info(&ioa_cfg
->pdev
->dev
, "Adapter firmware version: %02X%02X%02X%02X\n",
7896 ucode_vpd
->major_release
, ucode_vpd
->card_type
,
7897 ucode_vpd
->minor_release
[0], ucode_vpd
->minor_release
[1]);
7898 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7899 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7901 ioarcb
->cmd_pkt
.cdb
[0] = IPR_QUERY_IOA_CONFIG
;
7902 ioarcb
->cmd_pkt
.cdb
[6] = (ioa_cfg
->cfg_table_size
>> 16) & 0xff;
7903 ioarcb
->cmd_pkt
.cdb
[7] = (ioa_cfg
->cfg_table_size
>> 8) & 0xff;
7904 ioarcb
->cmd_pkt
.cdb
[8] = ioa_cfg
->cfg_table_size
& 0xff;
7906 ipr_init_ioadl(ipr_cmd
, ioa_cfg
->cfg_table_dma
, ioa_cfg
->cfg_table_size
,
7907 IPR_IOADL_FLAGS_READ_LAST
);
7909 ipr_cmd
->job_step
= ipr_init_res_table
;
7911 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7914 return IPR_RC_JOB_RETURN
;
7917 static int ipr_ioa_service_action_failed(struct ipr_cmnd
*ipr_cmd
)
7919 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7921 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
)
7922 return IPR_RC_JOB_CONTINUE
;
7924 return ipr_reset_cmd_failed(ipr_cmd
);
7927 static void ipr_build_ioa_service_action(struct ipr_cmnd
*ipr_cmd
,
7928 __be32 res_handle
, u8 sa_code
)
7930 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7932 ioarcb
->res_handle
= res_handle
;
7933 ioarcb
->cmd_pkt
.cdb
[0] = IPR_IOA_SERVICE_ACTION
;
7934 ioarcb
->cmd_pkt
.cdb
[1] = sa_code
;
7935 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7939 * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7945 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd
*ipr_cmd
)
7947 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7948 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7949 struct ipr_inquiry_pageC4
*pageC4
= &ioa_cfg
->vpd_cbs
->pageC4_data
;
7953 ipr_cmd
->job_step
= ipr_ioafp_query_ioa_cfg
;
7955 if (pageC4
->cache_cap
[0] & IPR_CAP_SYNC_CACHE
) {
7956 ipr_build_ioa_service_action(ipr_cmd
,
7957 cpu_to_be32(IPR_IOA_RES_HANDLE
),
7958 IPR_IOA_SA_CHANGE_CACHE_PARAMS
);
7960 ioarcb
->cmd_pkt
.cdb
[2] = 0x40;
7962 ipr_cmd
->job_step_failed
= ipr_ioa_service_action_failed
;
7963 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
7964 IPR_SET_SUP_DEVICE_TIMEOUT
);
7967 return IPR_RC_JOB_RETURN
;
7971 return IPR_RC_JOB_CONTINUE
;
7975 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7976 * @ipr_cmd: ipr command struct
7978 * This utility function sends an inquiry to the adapter.
7983 static void ipr_ioafp_inquiry(struct ipr_cmnd
*ipr_cmd
, u8 flags
, u8 page
,
7984 dma_addr_t dma_addr
, u8 xfer_len
)
7986 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7989 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7990 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7992 ioarcb
->cmd_pkt
.cdb
[0] = INQUIRY
;
7993 ioarcb
->cmd_pkt
.cdb
[1] = flags
;
7994 ioarcb
->cmd_pkt
.cdb
[2] = page
;
7995 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7997 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_READ_LAST
);
7999 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
8004 * ipr_inquiry_page_supported - Is the given inquiry page supported
8005 * @page0: inquiry page 0 buffer
8008 * This function determines if the specified inquiry page is supported.
8011 * 1 if page is supported / 0 if not
8013 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0
*page0
, u8 page
)
8017 for (i
= 0; i
< min_t(u8
, page0
->len
, IPR_INQUIRY_PAGE0_ENTRIES
); i
++)
8018 if (page0
->page
[i
] == page
)
8025 * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
8026 * @ipr_cmd: ipr command struct
8028 * This function sends a Page 0xC4 inquiry to the adapter
8029 * to retrieve software VPD information.
8032 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8034 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd
*ipr_cmd
)
8036 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8037 struct ipr_inquiry_page0
*page0
= &ioa_cfg
->vpd_cbs
->page0_data
;
8038 struct ipr_inquiry_pageC4
*pageC4
= &ioa_cfg
->vpd_cbs
->pageC4_data
;
8041 ipr_cmd
->job_step
= ipr_ioafp_set_caching_parameters
;
8042 memset(pageC4
, 0, sizeof(*pageC4
));
8044 if (ipr_inquiry_page_supported(page0
, 0xC4)) {
8045 ipr_ioafp_inquiry(ipr_cmd
, 1, 0xC4,
8046 (ioa_cfg
->vpd_cbs_dma
8047 + offsetof(struct ipr_misc_cbs
,
8049 sizeof(struct ipr_inquiry_pageC4
));
8050 return IPR_RC_JOB_RETURN
;
8054 return IPR_RC_JOB_CONTINUE
;
8058 * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
8059 * @ipr_cmd: ipr command struct
8061 * This function sends a Page 0xD0 inquiry to the adapter
8062 * to retrieve adapter capabilities.
8065 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8067 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd
*ipr_cmd
)
8069 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8070 struct ipr_inquiry_page0
*page0
= &ioa_cfg
->vpd_cbs
->page0_data
;
8071 struct ipr_inquiry_cap
*cap
= &ioa_cfg
->vpd_cbs
->cap
;
8074 ipr_cmd
->job_step
= ipr_ioafp_pageC4_inquiry
;
8075 memset(cap
, 0, sizeof(*cap
));
8077 if (ipr_inquiry_page_supported(page0
, 0xD0)) {
8078 ipr_ioafp_inquiry(ipr_cmd
, 1, 0xD0,
8079 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, cap
),
8080 sizeof(struct ipr_inquiry_cap
));
8081 return IPR_RC_JOB_RETURN
;
8085 return IPR_RC_JOB_CONTINUE
;
8089 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
8090 * @ipr_cmd: ipr command struct
8092 * This function sends a Page 3 inquiry to the adapter
8093 * to retrieve software VPD information.
8096 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8098 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd
*ipr_cmd
)
8100 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8104 ipr_cmd
->job_step
= ipr_ioafp_cap_inquiry
;
8106 ipr_ioafp_inquiry(ipr_cmd
, 1, 3,
8107 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, page3_data
),
8108 sizeof(struct ipr_inquiry_page3
));
8111 return IPR_RC_JOB_RETURN
;
8115 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
8116 * @ipr_cmd: ipr command struct
8118 * This function sends a Page 0 inquiry to the adapter
8119 * to retrieve supported inquiry pages.
8122 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8124 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd
*ipr_cmd
)
8126 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8131 /* Grab the type out of the VPD and store it away */
8132 memcpy(type
, ioa_cfg
->vpd_cbs
->ioa_vpd
.std_inq_data
.vpids
.product_id
, 4);
8134 ioa_cfg
->type
= simple_strtoul((char *)type
, NULL
, 16);
8136 if (ipr_invalid_adapter(ioa_cfg
)) {
8137 dev_err(&ioa_cfg
->pdev
->dev
,
8138 "Adapter not supported in this hardware configuration.\n");
8140 if (!ipr_testmode
) {
8141 ioa_cfg
->reset_retries
+= IPR_NUM_RESET_RELOAD_RETRIES
;
8142 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
8143 list_add_tail(&ipr_cmd
->queue
,
8144 &ioa_cfg
->hrrq
->hrrq_free_q
);
8145 return IPR_RC_JOB_RETURN
;
8149 ipr_cmd
->job_step
= ipr_ioafp_page3_inquiry
;
8151 ipr_ioafp_inquiry(ipr_cmd
, 1, 0,
8152 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, page0_data
),
8153 sizeof(struct ipr_inquiry_page0
));
8156 return IPR_RC_JOB_RETURN
;
8160 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
8161 * @ipr_cmd: ipr command struct
8163 * This function sends a standard inquiry to the adapter.
8168 static int ipr_ioafp_std_inquiry(struct ipr_cmnd
*ipr_cmd
)
8170 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8173 ipr_cmd
->job_step
= ipr_ioafp_page0_inquiry
;
8175 ipr_ioafp_inquiry(ipr_cmd
, 0, 0,
8176 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, ioa_vpd
),
8177 sizeof(struct ipr_ioa_vpd
));
8180 return IPR_RC_JOB_RETURN
;
8184 * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
8185 * @ipr_cmd: ipr command struct
8187 * This function send an Identify Host Request Response Queue
8188 * command to establish the HRRQ with the adapter.
8193 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd
*ipr_cmd
)
8195 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8196 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
8197 struct ipr_hrr_queue
*hrrq
;
8200 ipr_cmd
->job_step
= ipr_ioafp_std_inquiry
;
8201 if (ioa_cfg
->identify_hrrq_index
== 0)
8202 dev_info(&ioa_cfg
->pdev
->dev
, "Starting IOA initialization sequence.\n");
8204 if (ioa_cfg
->identify_hrrq_index
< ioa_cfg
->hrrq_num
) {
8205 hrrq
= &ioa_cfg
->hrrq
[ioa_cfg
->identify_hrrq_index
];
8207 ioarcb
->cmd_pkt
.cdb
[0] = IPR_ID_HOST_RR_Q
;
8208 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
8210 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
8212 ioarcb
->cmd_pkt
.cdb
[1] = 0x1;
8214 if (ioa_cfg
->nvectors
== 1)
8215 ioarcb
->cmd_pkt
.cdb
[1] &= ~IPR_ID_HRRQ_SELE_ENABLE
;
8217 ioarcb
->cmd_pkt
.cdb
[1] |= IPR_ID_HRRQ_SELE_ENABLE
;
8219 ioarcb
->cmd_pkt
.cdb
[2] =
8220 ((u64
) hrrq
->host_rrq_dma
>> 24) & 0xff;
8221 ioarcb
->cmd_pkt
.cdb
[3] =
8222 ((u64
) hrrq
->host_rrq_dma
>> 16) & 0xff;
8223 ioarcb
->cmd_pkt
.cdb
[4] =
8224 ((u64
) hrrq
->host_rrq_dma
>> 8) & 0xff;
8225 ioarcb
->cmd_pkt
.cdb
[5] =
8226 ((u64
) hrrq
->host_rrq_dma
) & 0xff;
8227 ioarcb
->cmd_pkt
.cdb
[7] =
8228 ((sizeof(u32
) * hrrq
->size
) >> 8) & 0xff;
8229 ioarcb
->cmd_pkt
.cdb
[8] =
8230 (sizeof(u32
) * hrrq
->size
) & 0xff;
8232 if (ioarcb
->cmd_pkt
.cdb
[1] & IPR_ID_HRRQ_SELE_ENABLE
)
8233 ioarcb
->cmd_pkt
.cdb
[9] =
8234 ioa_cfg
->identify_hrrq_index
;
8236 if (ioa_cfg
->sis64
) {
8237 ioarcb
->cmd_pkt
.cdb
[10] =
8238 ((u64
) hrrq
->host_rrq_dma
>> 56) & 0xff;
8239 ioarcb
->cmd_pkt
.cdb
[11] =
8240 ((u64
) hrrq
->host_rrq_dma
>> 48) & 0xff;
8241 ioarcb
->cmd_pkt
.cdb
[12] =
8242 ((u64
) hrrq
->host_rrq_dma
>> 40) & 0xff;
8243 ioarcb
->cmd_pkt
.cdb
[13] =
8244 ((u64
) hrrq
->host_rrq_dma
>> 32) & 0xff;
8247 if (ioarcb
->cmd_pkt
.cdb
[1] & IPR_ID_HRRQ_SELE_ENABLE
)
8248 ioarcb
->cmd_pkt
.cdb
[14] =
8249 ioa_cfg
->identify_hrrq_index
;
8251 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
8252 IPR_INTERNAL_TIMEOUT
);
8254 if (++ioa_cfg
->identify_hrrq_index
< ioa_cfg
->hrrq_num
)
8255 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8258 return IPR_RC_JOB_RETURN
;
8262 return IPR_RC_JOB_CONTINUE
;
8266 * ipr_reset_timer_done - Adapter reset timer function
8267 * @ipr_cmd: ipr command struct
8269 * Description: This function is used in adapter reset processing
8270 * for timing events. If the reset_cmd pointer in the IOA
8271 * config struct is not this adapter's we are doing nested
8272 * resets and fail_all_ops will take care of freeing the
8278 static void ipr_reset_timer_done(struct timer_list
*t
)
8280 struct ipr_cmnd
*ipr_cmd
= from_timer(ipr_cmd
, t
, timer
);
8281 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8282 unsigned long lock_flags
= 0;
8284 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
8286 if (ioa_cfg
->reset_cmd
== ipr_cmd
) {
8287 list_del(&ipr_cmd
->queue
);
8288 ipr_cmd
->done(ipr_cmd
);
8291 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
8295 * ipr_reset_start_timer - Start a timer for adapter reset job
8296 * @ipr_cmd: ipr command struct
8297 * @timeout: timeout value
8299 * Description: This function is used in adapter reset processing
8300 * for timing events. If the reset_cmd pointer in the IOA
8301 * config struct is not this adapter's we are doing nested
8302 * resets and fail_all_ops will take care of freeing the
8308 static void ipr_reset_start_timer(struct ipr_cmnd
*ipr_cmd
,
8309 unsigned long timeout
)
8313 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8314 ipr_cmd
->done
= ipr_reset_ioa_job
;
8316 ipr_cmd
->timer
.expires
= jiffies
+ timeout
;
8317 ipr_cmd
->timer
.function
= ipr_reset_timer_done
;
8318 add_timer(&ipr_cmd
->timer
);
8322 * ipr_init_ioa_mem - Initialize ioa_cfg control block
8323 * @ioa_cfg: ioa cfg struct
8328 static void ipr_init_ioa_mem(struct ipr_ioa_cfg
*ioa_cfg
)
8330 struct ipr_hrr_queue
*hrrq
;
8332 for_each_hrrq(hrrq
, ioa_cfg
) {
8333 spin_lock(&hrrq
->_lock
);
8334 memset(hrrq
->host_rrq
, 0, sizeof(u32
) * hrrq
->size
);
8336 /* Initialize Host RRQ pointers */
8337 hrrq
->hrrq_start
= hrrq
->host_rrq
;
8338 hrrq
->hrrq_end
= &hrrq
->host_rrq
[hrrq
->size
- 1];
8339 hrrq
->hrrq_curr
= hrrq
->hrrq_start
;
8340 hrrq
->toggle_bit
= 1;
8341 spin_unlock(&hrrq
->_lock
);
8345 ioa_cfg
->identify_hrrq_index
= 0;
8346 if (ioa_cfg
->hrrq_num
== 1)
8347 atomic_set(&ioa_cfg
->hrrq_index
, 0);
8349 atomic_set(&ioa_cfg
->hrrq_index
, 1);
8351 /* Zero out config table */
8352 memset(ioa_cfg
->u
.cfg_table
, 0, ioa_cfg
->cfg_table_size
);
8356 * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8357 * @ipr_cmd: ipr command struct
8360 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8362 static int ipr_reset_next_stage(struct ipr_cmnd
*ipr_cmd
)
8364 unsigned long stage
, stage_time
;
8366 volatile u32 int_reg
;
8367 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8370 feedback
= readl(ioa_cfg
->regs
.init_feedback_reg
);
8371 stage
= feedback
& IPR_IPL_INIT_STAGE_MASK
;
8372 stage_time
= feedback
& IPR_IPL_INIT_STAGE_TIME_MASK
;
8374 ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage
, stage_time
);
8376 /* sanity check the stage_time value */
8377 if (stage_time
== 0)
8378 stage_time
= IPR_IPL_INIT_DEFAULT_STAGE_TIME
;
8379 else if (stage_time
< IPR_IPL_INIT_MIN_STAGE_TIME
)
8380 stage_time
= IPR_IPL_INIT_MIN_STAGE_TIME
;
8381 else if (stage_time
> IPR_LONG_OPERATIONAL_TIMEOUT
)
8382 stage_time
= IPR_LONG_OPERATIONAL_TIMEOUT
;
8384 if (stage
== IPR_IPL_INIT_STAGE_UNKNOWN
) {
8385 writel(IPR_PCII_IPL_STAGE_CHANGE
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
8386 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8387 stage_time
= ioa_cfg
->transop_timeout
;
8388 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8389 } else if (stage
== IPR_IPL_INIT_STAGE_TRANSOP
) {
8390 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
8391 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
8392 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8393 maskval
= IPR_PCII_IPL_STAGE_CHANGE
;
8394 maskval
= (maskval
<< 32) | IPR_PCII_IOA_TRANS_TO_OPER
;
8395 writeq(maskval
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
8396 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8397 return IPR_RC_JOB_CONTINUE
;
8401 ipr_cmd
->timer
.expires
= jiffies
+ stage_time
* HZ
;
8402 ipr_cmd
->timer
.function
= ipr_oper_timeout
;
8403 ipr_cmd
->done
= ipr_reset_ioa_job
;
8404 add_timer(&ipr_cmd
->timer
);
8406 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8408 return IPR_RC_JOB_RETURN
;
8412 * ipr_reset_enable_ioa - Enable the IOA following a reset.
8413 * @ipr_cmd: ipr command struct
8415 * This function reinitializes some control blocks and
8416 * enables destructive diagnostics on the adapter.
8421 static int ipr_reset_enable_ioa(struct ipr_cmnd
*ipr_cmd
)
8423 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8424 volatile u32 int_reg
;
8425 volatile u64 maskval
;
8429 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8430 ipr_init_ioa_mem(ioa_cfg
);
8432 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
8433 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
8434 ioa_cfg
->hrrq
[i
].allow_interrupts
= 1;
8435 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
8437 if (ioa_cfg
->sis64
) {
8438 /* Set the adapter to the correct endian mode. */
8439 writel(IPR_ENDIAN_SWAP_KEY
, ioa_cfg
->regs
.endian_swap_reg
);
8440 int_reg
= readl(ioa_cfg
->regs
.endian_swap_reg
);
8443 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
8445 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
8446 writel((IPR_PCII_ERROR_INTERRUPTS
| IPR_PCII_HRRQ_UPDATED
),
8447 ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
8448 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8449 return IPR_RC_JOB_CONTINUE
;
8452 /* Enable destructive diagnostics on IOA */
8453 writel(ioa_cfg
->doorbell
, ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8455 if (ioa_cfg
->sis64
) {
8456 maskval
= IPR_PCII_IPL_STAGE_CHANGE
;
8457 maskval
= (maskval
<< 32) | IPR_PCII_OPER_INTERRUPTS
;
8458 writeq(maskval
, ioa_cfg
->regs
.clr_interrupt_mask_reg
);
8460 writel(IPR_PCII_OPER_INTERRUPTS
, ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
8462 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8464 dev_info(&ioa_cfg
->pdev
->dev
, "Initializing IOA.\n");
8466 if (ioa_cfg
->sis64
) {
8467 ipr_cmd
->job_step
= ipr_reset_next_stage
;
8468 return IPR_RC_JOB_CONTINUE
;
8471 ipr_cmd
->timer
.expires
= jiffies
+ (ioa_cfg
->transop_timeout
* HZ
);
8472 ipr_cmd
->timer
.function
= ipr_oper_timeout
;
8473 ipr_cmd
->done
= ipr_reset_ioa_job
;
8474 add_timer(&ipr_cmd
->timer
);
8475 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8478 return IPR_RC_JOB_RETURN
;
8482 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8483 * @ipr_cmd: ipr command struct
8485 * This function is invoked when an adapter dump has run out
8486 * of processing time.
8489 * IPR_RC_JOB_CONTINUE
8491 static int ipr_reset_wait_for_dump(struct ipr_cmnd
*ipr_cmd
)
8493 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8495 if (ioa_cfg
->sdt_state
== GET_DUMP
)
8496 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
8497 else if (ioa_cfg
->sdt_state
== READ_DUMP
)
8498 ioa_cfg
->sdt_state
= ABORT_DUMP
;
8500 ioa_cfg
->dump_timeout
= 1;
8501 ipr_cmd
->job_step
= ipr_reset_alert
;
8503 return IPR_RC_JOB_CONTINUE
;
8507 * ipr_unit_check_no_data - Log a unit check/no data error log
8508 * @ioa_cfg: ioa config struct
8510 * Logs an error indicating the adapter unit checked, but for some
8511 * reason, we were unable to fetch the unit check buffer.
8516 static void ipr_unit_check_no_data(struct ipr_ioa_cfg
*ioa_cfg
)
8518 ioa_cfg
->errors_logged
++;
8519 dev_err(&ioa_cfg
->pdev
->dev
, "IOA unit check with no data\n");
8523 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8524 * @ioa_cfg: ioa config struct
8526 * Fetches the unit check buffer from the adapter by clocking the data
8527 * through the mailbox register.
8532 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg
*ioa_cfg
)
8534 unsigned long mailbox
;
8535 struct ipr_hostrcb
*hostrcb
;
8536 struct ipr_uc_sdt sdt
;
8540 mailbox
= readl(ioa_cfg
->ioa_mailbox
);
8542 if (!ioa_cfg
->sis64
&& !ipr_sdt_is_fmt2(mailbox
)) {
8543 ipr_unit_check_no_data(ioa_cfg
);
8547 memset(&sdt
, 0, sizeof(struct ipr_uc_sdt
));
8548 rc
= ipr_get_ldump_data_section(ioa_cfg
, mailbox
, (__be32
*) &sdt
,
8549 (sizeof(struct ipr_uc_sdt
)) / sizeof(__be32
));
8551 if (rc
|| !(sdt
.entry
[0].flags
& IPR_SDT_VALID_ENTRY
) ||
8552 ((be32_to_cpu(sdt
.hdr
.state
) != IPR_FMT3_SDT_READY_TO_USE
) &&
8553 (be32_to_cpu(sdt
.hdr
.state
) != IPR_FMT2_SDT_READY_TO_USE
))) {
8554 ipr_unit_check_no_data(ioa_cfg
);
8558 /* Find length of the first sdt entry (UC buffer) */
8559 if (be32_to_cpu(sdt
.hdr
.state
) == IPR_FMT3_SDT_READY_TO_USE
)
8560 length
= be32_to_cpu(sdt
.entry
[0].end_token
);
8562 length
= (be32_to_cpu(sdt
.entry
[0].end_token
) -
8563 be32_to_cpu(sdt
.entry
[0].start_token
)) &
8564 IPR_FMT2_MBX_ADDR_MASK
;
8566 hostrcb
= list_entry(ioa_cfg
->hostrcb_free_q
.next
,
8567 struct ipr_hostrcb
, queue
);
8568 list_del_init(&hostrcb
->queue
);
8569 memset(&hostrcb
->hcam
, 0, sizeof(hostrcb
->hcam
));
8571 rc
= ipr_get_ldump_data_section(ioa_cfg
,
8572 be32_to_cpu(sdt
.entry
[0].start_token
),
8573 (__be32
*)&hostrcb
->hcam
,
8574 min(length
, (int)sizeof(hostrcb
->hcam
)) / sizeof(__be32
));
8577 ipr_handle_log_data(ioa_cfg
, hostrcb
);
8578 ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error
.fd_ioasc
);
8579 if (ioasc
== IPR_IOASC_NR_IOA_RESET_REQUIRED
&&
8580 ioa_cfg
->sdt_state
== GET_DUMP
)
8581 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
8583 ipr_unit_check_no_data(ioa_cfg
);
8585 list_add_tail(&hostrcb
->queue
, &ioa_cfg
->hostrcb_free_q
);
8589 * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8590 * @ipr_cmd: ipr command struct
8592 * Description: This function will call to get the unit check buffer.
8597 static int ipr_reset_get_unit_check_job(struct ipr_cmnd
*ipr_cmd
)
8599 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8602 ioa_cfg
->ioa_unit_checked
= 0;
8603 ipr_get_unit_check_buffer(ioa_cfg
);
8604 ipr_cmd
->job_step
= ipr_reset_alert
;
8605 ipr_reset_start_timer(ipr_cmd
, 0);
8608 return IPR_RC_JOB_RETURN
;
8611 static int ipr_dump_mailbox_wait(struct ipr_cmnd
*ipr_cmd
)
8613 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8617 if (ioa_cfg
->sdt_state
!= GET_DUMP
)
8618 return IPR_RC_JOB_RETURN
;
8620 if (!ioa_cfg
->sis64
|| !ipr_cmd
->u
.time_left
||
8621 (readl(ioa_cfg
->regs
.sense_interrupt_reg
) &
8622 IPR_PCII_MAILBOX_STABLE
)) {
8624 if (!ipr_cmd
->u
.time_left
)
8625 dev_err(&ioa_cfg
->pdev
->dev
,
8626 "Timed out waiting for Mailbox register.\n");
8628 ioa_cfg
->sdt_state
= READ_DUMP
;
8629 ioa_cfg
->dump_timeout
= 0;
8631 ipr_reset_start_timer(ipr_cmd
, IPR_SIS64_DUMP_TIMEOUT
);
8633 ipr_reset_start_timer(ipr_cmd
, IPR_SIS32_DUMP_TIMEOUT
);
8634 ipr_cmd
->job_step
= ipr_reset_wait_for_dump
;
8635 schedule_work(&ioa_cfg
->work_q
);
8638 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8639 ipr_reset_start_timer(ipr_cmd
,
8640 IPR_CHECK_FOR_RESET_TIMEOUT
);
8644 return IPR_RC_JOB_RETURN
;
8648 * ipr_reset_restore_cfg_space - Restore PCI config space.
8649 * @ipr_cmd: ipr command struct
8651 * Description: This function restores the saved PCI config space of
8652 * the adapter, fails all outstanding ops back to the callers, and
8653 * fetches the dump/unit check if applicable to this reset.
8656 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8658 static int ipr_reset_restore_cfg_space(struct ipr_cmnd
*ipr_cmd
)
8660 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8664 ioa_cfg
->pdev
->state_saved
= true;
8665 pci_restore_state(ioa_cfg
->pdev
);
8667 if (ipr_set_pcix_cmd_reg(ioa_cfg
)) {
8668 ipr_cmd
->s
.ioasa
.hdr
.ioasc
= cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR
);
8669 return IPR_RC_JOB_CONTINUE
;
8672 ipr_fail_all_ops(ioa_cfg
);
8674 if (ioa_cfg
->sis64
) {
8675 /* Set the adapter to the correct endian mode. */
8676 writel(IPR_ENDIAN_SWAP_KEY
, ioa_cfg
->regs
.endian_swap_reg
);
8677 int_reg
= readl(ioa_cfg
->regs
.endian_swap_reg
);
8680 if (ioa_cfg
->ioa_unit_checked
) {
8681 if (ioa_cfg
->sis64
) {
8682 ipr_cmd
->job_step
= ipr_reset_get_unit_check_job
;
8683 ipr_reset_start_timer(ipr_cmd
, IPR_DUMP_DELAY_TIMEOUT
);
8684 return IPR_RC_JOB_RETURN
;
8686 ioa_cfg
->ioa_unit_checked
= 0;
8687 ipr_get_unit_check_buffer(ioa_cfg
);
8688 ipr_cmd
->job_step
= ipr_reset_alert
;
8689 ipr_reset_start_timer(ipr_cmd
, 0);
8690 return IPR_RC_JOB_RETURN
;
8694 if (ioa_cfg
->in_ioa_bringdown
) {
8695 ipr_cmd
->job_step
= ipr_ioa_bringdown_done
;
8696 } else if (ioa_cfg
->sdt_state
== GET_DUMP
) {
8697 ipr_cmd
->job_step
= ipr_dump_mailbox_wait
;
8698 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_MAILBOX
;
8700 ipr_cmd
->job_step
= ipr_reset_enable_ioa
;
8704 return IPR_RC_JOB_CONTINUE
;
8708 * ipr_reset_bist_done - BIST has completed on the adapter.
8709 * @ipr_cmd: ipr command struct
8711 * Description: Unblock config space and resume the reset process.
8714 * IPR_RC_JOB_CONTINUE
8716 static int ipr_reset_bist_done(struct ipr_cmnd
*ipr_cmd
)
8718 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8721 if (ioa_cfg
->cfg_locked
)
8722 pci_cfg_access_unlock(ioa_cfg
->pdev
);
8723 ioa_cfg
->cfg_locked
= 0;
8724 ipr_cmd
->job_step
= ipr_reset_restore_cfg_space
;
8726 return IPR_RC_JOB_CONTINUE
;
8730 * ipr_reset_start_bist - Run BIST on the adapter.
8731 * @ipr_cmd: ipr command struct
8733 * Description: This function runs BIST on the adapter, then delays 2 seconds.
8736 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8738 static int ipr_reset_start_bist(struct ipr_cmnd
*ipr_cmd
)
8740 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8741 int rc
= PCIBIOS_SUCCESSFUL
;
8744 if (ioa_cfg
->ipr_chip
->bist_method
== IPR_MMIO
)
8745 writel(IPR_UPROCI_SIS64_START_BIST
,
8746 ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8748 rc
= pci_write_config_byte(ioa_cfg
->pdev
, PCI_BIST
, PCI_BIST_START
);
8750 if (rc
== PCIBIOS_SUCCESSFUL
) {
8751 ipr_cmd
->job_step
= ipr_reset_bist_done
;
8752 ipr_reset_start_timer(ipr_cmd
, IPR_WAIT_FOR_BIST_TIMEOUT
);
8753 rc
= IPR_RC_JOB_RETURN
;
8755 if (ioa_cfg
->cfg_locked
)
8756 pci_cfg_access_unlock(ipr_cmd
->ioa_cfg
->pdev
);
8757 ioa_cfg
->cfg_locked
= 0;
8758 ipr_cmd
->s
.ioasa
.hdr
.ioasc
= cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR
);
8759 rc
= IPR_RC_JOB_CONTINUE
;
8767 * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8768 * @ipr_cmd: ipr command struct
8770 * Description: This clears PCI reset to the adapter and delays two seconds.
8775 static int ipr_reset_slot_reset_done(struct ipr_cmnd
*ipr_cmd
)
8778 ipr_cmd
->job_step
= ipr_reset_bist_done
;
8779 ipr_reset_start_timer(ipr_cmd
, IPR_WAIT_FOR_BIST_TIMEOUT
);
8781 return IPR_RC_JOB_RETURN
;
8785 * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8786 * @work: work struct
8788 * Description: This pulses warm reset to a slot.
8791 static void ipr_reset_reset_work(struct work_struct
*work
)
8793 struct ipr_cmnd
*ipr_cmd
= container_of(work
, struct ipr_cmnd
, work
);
8794 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8795 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
8796 unsigned long lock_flags
= 0;
8799 pci_set_pcie_reset_state(pdev
, pcie_warm_reset
);
8800 msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT
));
8801 pci_set_pcie_reset_state(pdev
, pcie_deassert_reset
);
8803 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
8804 if (ioa_cfg
->reset_cmd
== ipr_cmd
)
8805 ipr_reset_ioa_job(ipr_cmd
);
8806 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
8811 * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8812 * @ipr_cmd: ipr command struct
8814 * Description: This asserts PCI reset to the adapter.
8819 static int ipr_reset_slot_reset(struct ipr_cmnd
*ipr_cmd
)
8821 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8824 INIT_WORK(&ipr_cmd
->work
, ipr_reset_reset_work
);
8825 queue_work(ioa_cfg
->reset_work_q
, &ipr_cmd
->work
);
8826 ipr_cmd
->job_step
= ipr_reset_slot_reset_done
;
8828 return IPR_RC_JOB_RETURN
;
8832 * ipr_reset_block_config_access_wait - Wait for permission to block config access
8833 * @ipr_cmd: ipr command struct
8835 * Description: This attempts to block config access to the IOA.
8838 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8840 static int ipr_reset_block_config_access_wait(struct ipr_cmnd
*ipr_cmd
)
8842 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8843 int rc
= IPR_RC_JOB_CONTINUE
;
8845 if (pci_cfg_access_trylock(ioa_cfg
->pdev
)) {
8846 ioa_cfg
->cfg_locked
= 1;
8847 ipr_cmd
->job_step
= ioa_cfg
->reset
;
8849 if (ipr_cmd
->u
.time_left
) {
8850 rc
= IPR_RC_JOB_RETURN
;
8851 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8852 ipr_reset_start_timer(ipr_cmd
,
8853 IPR_CHECK_FOR_RESET_TIMEOUT
);
8855 ipr_cmd
->job_step
= ioa_cfg
->reset
;
8856 dev_err(&ioa_cfg
->pdev
->dev
,
8857 "Timed out waiting to lock config access. Resetting anyway.\n");
8865 * ipr_reset_block_config_access - Block config access to the IOA
8866 * @ipr_cmd: ipr command struct
8868 * Description: This attempts to block config access to the IOA
8871 * IPR_RC_JOB_CONTINUE
8873 static int ipr_reset_block_config_access(struct ipr_cmnd
*ipr_cmd
)
8875 ipr_cmd
->ioa_cfg
->cfg_locked
= 0;
8876 ipr_cmd
->job_step
= ipr_reset_block_config_access_wait
;
8877 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_RESET_TIMEOUT
;
8878 return IPR_RC_JOB_CONTINUE
;
8882 * ipr_reset_allowed - Query whether or not IOA can be reset
8883 * @ioa_cfg: ioa config struct
8886 * 0 if reset not allowed / non-zero if reset is allowed
8888 static int ipr_reset_allowed(struct ipr_ioa_cfg
*ioa_cfg
)
8890 volatile u32 temp_reg
;
8892 temp_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
8893 return ((temp_reg
& IPR_PCII_CRITICAL_OPERATION
) == 0);
8897 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8898 * @ipr_cmd: ipr command struct
8900 * Description: This function waits for adapter permission to run BIST,
8901 * then runs BIST. If the adapter does not give permission after a
8902 * reasonable time, we will reset the adapter anyway. The impact of
8903 * resetting the adapter without warning the adapter is the risk of
8904 * losing the persistent error log on the adapter. If the adapter is
8905 * reset while it is writing to the flash on the adapter, the flash
8906 * segment will have bad ECC and be zeroed.
8909 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8911 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd
*ipr_cmd
)
8913 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8914 int rc
= IPR_RC_JOB_RETURN
;
8916 if (!ipr_reset_allowed(ioa_cfg
) && ipr_cmd
->u
.time_left
) {
8917 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8918 ipr_reset_start_timer(ipr_cmd
, IPR_CHECK_FOR_RESET_TIMEOUT
);
8920 ipr_cmd
->job_step
= ipr_reset_block_config_access
;
8921 rc
= IPR_RC_JOB_CONTINUE
;
8928 * ipr_reset_alert - Alert the adapter of a pending reset
8929 * @ipr_cmd: ipr command struct
8931 * Description: This function alerts the adapter that it will be reset.
8932 * If memory space is not currently enabled, proceed directly
8933 * to running BIST on the adapter. The timer must always be started
8934 * so we guarantee we do not run BIST from ipr_isr.
8939 static int ipr_reset_alert(struct ipr_cmnd
*ipr_cmd
)
8941 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8946 rc
= pci_read_config_word(ioa_cfg
->pdev
, PCI_COMMAND
, &cmd_reg
);
8948 if ((rc
== PCIBIOS_SUCCESSFUL
) && (cmd_reg
& PCI_COMMAND_MEMORY
)) {
8949 ipr_mask_and_clear_interrupts(ioa_cfg
, ~0);
8950 writel(IPR_UPROCI_RESET_ALERT
, ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8951 ipr_cmd
->job_step
= ipr_reset_wait_to_start_bist
;
8953 ipr_cmd
->job_step
= ipr_reset_block_config_access
;
8956 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_RESET_TIMEOUT
;
8957 ipr_reset_start_timer(ipr_cmd
, IPR_CHECK_FOR_RESET_TIMEOUT
);
8960 return IPR_RC_JOB_RETURN
;
8964 * ipr_reset_quiesce_done - Complete IOA disconnect
8965 * @ipr_cmd: ipr command struct
8967 * Description: Freeze the adapter to complete quiesce processing
8970 * IPR_RC_JOB_CONTINUE
8972 static int ipr_reset_quiesce_done(struct ipr_cmnd
*ipr_cmd
)
8974 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8977 ipr_cmd
->job_step
= ipr_ioa_bringdown_done
;
8978 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
8980 return IPR_RC_JOB_CONTINUE
;
8984 * ipr_reset_cancel_hcam_done - Check for outstanding commands
8985 * @ipr_cmd: ipr command struct
8987 * Description: Ensure nothing is outstanding to the IOA and
8988 * proceed with IOA disconnect. Otherwise reset the IOA.
8991 * IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
8993 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd
*ipr_cmd
)
8995 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8996 struct ipr_cmnd
*loop_cmd
;
8997 struct ipr_hrr_queue
*hrrq
;
8998 int rc
= IPR_RC_JOB_CONTINUE
;
9002 ipr_cmd
->job_step
= ipr_reset_quiesce_done
;
9004 for_each_hrrq(hrrq
, ioa_cfg
) {
9005 spin_lock(&hrrq
->_lock
);
9006 list_for_each_entry(loop_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
9008 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9009 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
9010 rc
= IPR_RC_JOB_RETURN
;
9013 spin_unlock(&hrrq
->_lock
);
9024 * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
9025 * @ipr_cmd: ipr command struct
9027 * Description: Cancel any oustanding HCAMs to the IOA.
9030 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9032 static int ipr_reset_cancel_hcam(struct ipr_cmnd
*ipr_cmd
)
9034 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9035 int rc
= IPR_RC_JOB_CONTINUE
;
9036 struct ipr_cmd_pkt
*cmd_pkt
;
9037 struct ipr_cmnd
*hcam_cmd
;
9038 struct ipr_hrr_queue
*hrrq
= &ioa_cfg
->hrrq
[IPR_INIT_HRRQ
];
9041 ipr_cmd
->job_step
= ipr_reset_cancel_hcam_done
;
9043 if (!hrrq
->ioa_is_dead
) {
9044 if (!list_empty(&ioa_cfg
->hostrcb_pending_q
)) {
9045 list_for_each_entry(hcam_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
9046 if (hcam_cmd
->ioarcb
.cmd_pkt
.cdb
[0] != IPR_HOST_CONTROLLED_ASYNC
)
9049 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
9050 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
9051 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
9052 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
9053 cmd_pkt
->cdb
[0] = IPR_CANCEL_REQUEST
;
9054 cmd_pkt
->cdb
[1] = IPR_CANCEL_64BIT_IOARCB
;
9055 cmd_pkt
->cdb
[10] = ((u64
) hcam_cmd
->dma_addr
>> 56) & 0xff;
9056 cmd_pkt
->cdb
[11] = ((u64
) hcam_cmd
->dma_addr
>> 48) & 0xff;
9057 cmd_pkt
->cdb
[12] = ((u64
) hcam_cmd
->dma_addr
>> 40) & 0xff;
9058 cmd_pkt
->cdb
[13] = ((u64
) hcam_cmd
->dma_addr
>> 32) & 0xff;
9059 cmd_pkt
->cdb
[2] = ((u64
) hcam_cmd
->dma_addr
>> 24) & 0xff;
9060 cmd_pkt
->cdb
[3] = ((u64
) hcam_cmd
->dma_addr
>> 16) & 0xff;
9061 cmd_pkt
->cdb
[4] = ((u64
) hcam_cmd
->dma_addr
>> 8) & 0xff;
9062 cmd_pkt
->cdb
[5] = ((u64
) hcam_cmd
->dma_addr
) & 0xff;
9064 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
9065 IPR_CANCEL_TIMEOUT
);
9067 rc
= IPR_RC_JOB_RETURN
;
9068 ipr_cmd
->job_step
= ipr_reset_cancel_hcam
;
9073 ipr_cmd
->job_step
= ipr_reset_alert
;
9080 * ipr_reset_ucode_download_done - Microcode download completion
9081 * @ipr_cmd: ipr command struct
9083 * Description: This function unmaps the microcode download buffer.
9086 * IPR_RC_JOB_CONTINUE
9088 static int ipr_reset_ucode_download_done(struct ipr_cmnd
*ipr_cmd
)
9090 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9091 struct ipr_sglist
*sglist
= ioa_cfg
->ucode_sglist
;
9093 dma_unmap_sg(&ioa_cfg
->pdev
->dev
, sglist
->scatterlist
,
9094 sglist
->num_sg
, DMA_TO_DEVICE
);
9096 ipr_cmd
->job_step
= ipr_reset_alert
;
9097 return IPR_RC_JOB_CONTINUE
;
9101 * ipr_reset_ucode_download - Download microcode to the adapter
9102 * @ipr_cmd: ipr command struct
9104 * Description: This function checks to see if it there is microcode
9105 * to download to the adapter. If there is, a download is performed.
9108 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9110 static int ipr_reset_ucode_download(struct ipr_cmnd
*ipr_cmd
)
9112 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9113 struct ipr_sglist
*sglist
= ioa_cfg
->ucode_sglist
;
9116 ipr_cmd
->job_step
= ipr_reset_alert
;
9119 return IPR_RC_JOB_CONTINUE
;
9121 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
9122 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
9123 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = WRITE_BUFFER
;
9124 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE
;
9125 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[6] = (sglist
->buffer_len
& 0xff0000) >> 16;
9126 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[7] = (sglist
->buffer_len
& 0x00ff00) >> 8;
9127 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[8] = sglist
->buffer_len
& 0x0000ff;
9130 ipr_build_ucode_ioadl64(ipr_cmd
, sglist
);
9132 ipr_build_ucode_ioadl(ipr_cmd
, sglist
);
9133 ipr_cmd
->job_step
= ipr_reset_ucode_download_done
;
9135 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
9136 IPR_WRITE_BUFFER_TIMEOUT
);
9139 return IPR_RC_JOB_RETURN
;
9143 * ipr_reset_shutdown_ioa - Shutdown the adapter
9144 * @ipr_cmd: ipr command struct
9146 * Description: This function issues an adapter shutdown of the
9147 * specified type to the specified adapter as part of the
9148 * adapter reset job.
9151 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9153 static int ipr_reset_shutdown_ioa(struct ipr_cmnd
*ipr_cmd
)
9155 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9156 enum ipr_shutdown_type shutdown_type
= ipr_cmd
->u
.shutdown_type
;
9157 unsigned long timeout
;
9158 int rc
= IPR_RC_JOB_CONTINUE
;
9161 if (shutdown_type
== IPR_SHUTDOWN_QUIESCE
)
9162 ipr_cmd
->job_step
= ipr_reset_cancel_hcam
;
9163 else if (shutdown_type
!= IPR_SHUTDOWN_NONE
&&
9164 !ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
9165 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
9166 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
9167 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = IPR_IOA_SHUTDOWN
;
9168 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = shutdown_type
;
9170 if (shutdown_type
== IPR_SHUTDOWN_NORMAL
)
9171 timeout
= IPR_SHUTDOWN_TIMEOUT
;
9172 else if (shutdown_type
== IPR_SHUTDOWN_PREPARE_FOR_NORMAL
)
9173 timeout
= IPR_INTERNAL_TIMEOUT
;
9174 else if (ioa_cfg
->dual_raid
&& ipr_dual_ioa_raid
)
9175 timeout
= IPR_DUAL_IOA_ABBR_SHUTDOWN_TO
;
9177 timeout
= IPR_ABBREV_SHUTDOWN_TIMEOUT
;
9179 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, timeout
);
9181 rc
= IPR_RC_JOB_RETURN
;
9182 ipr_cmd
->job_step
= ipr_reset_ucode_download
;
9184 ipr_cmd
->job_step
= ipr_reset_alert
;
9191 * ipr_reset_ioa_job - Adapter reset job
9192 * @ipr_cmd: ipr command struct
9194 * Description: This function is the job router for the adapter reset job.
9199 static void ipr_reset_ioa_job(struct ipr_cmnd
*ipr_cmd
)
9202 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9205 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
9207 if (ioa_cfg
->reset_cmd
!= ipr_cmd
) {
9209 * We are doing nested adapter resets and this is
9210 * not the current reset job.
9212 list_add_tail(&ipr_cmd
->queue
,
9213 &ipr_cmd
->hrrq
->hrrq_free_q
);
9217 if (IPR_IOASC_SENSE_KEY(ioasc
)) {
9218 rc
= ipr_cmd
->job_step_failed(ipr_cmd
);
9219 if (rc
== IPR_RC_JOB_RETURN
)
9223 ipr_reinit_ipr_cmnd(ipr_cmd
);
9224 ipr_cmd
->job_step_failed
= ipr_reset_cmd_failed
;
9225 rc
= ipr_cmd
->job_step(ipr_cmd
);
9226 } while (rc
== IPR_RC_JOB_CONTINUE
);
9230 * _ipr_initiate_ioa_reset - Initiate an adapter reset
9231 * @ioa_cfg: ioa config struct
9232 * @job_step: first job step of reset job
9233 * @shutdown_type: shutdown type
9235 * Description: This function will initiate the reset of the given adapter
9236 * starting at the selected job step.
9237 * If the caller needs to wait on the completion of the reset,
9238 * the caller must sleep on the reset_wait_q.
9243 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg
*ioa_cfg
,
9244 int (*job_step
) (struct ipr_cmnd
*),
9245 enum ipr_shutdown_type shutdown_type
)
9247 struct ipr_cmnd
*ipr_cmd
;
9250 ioa_cfg
->in_reset_reload
= 1;
9251 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9252 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9253 ioa_cfg
->hrrq
[i
].allow_cmds
= 0;
9254 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9257 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
) {
9258 ioa_cfg
->scsi_unblock
= 0;
9259 ioa_cfg
->scsi_blocked
= 1;
9260 scsi_block_requests(ioa_cfg
->host
);
9263 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
9264 ioa_cfg
->reset_cmd
= ipr_cmd
;
9265 ipr_cmd
->job_step
= job_step
;
9266 ipr_cmd
->u
.shutdown_type
= shutdown_type
;
9268 ipr_reset_ioa_job(ipr_cmd
);
9272 * ipr_initiate_ioa_reset - Initiate an adapter reset
9273 * @ioa_cfg: ioa config struct
9274 * @shutdown_type: shutdown type
9276 * Description: This function will initiate the reset of the given adapter.
9277 * If the caller needs to wait on the completion of the reset,
9278 * the caller must sleep on the reset_wait_q.
9283 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg
*ioa_cfg
,
9284 enum ipr_shutdown_type shutdown_type
)
9288 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
9291 if (ioa_cfg
->in_reset_reload
) {
9292 if (ioa_cfg
->sdt_state
== GET_DUMP
)
9293 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
9294 else if (ioa_cfg
->sdt_state
== READ_DUMP
)
9295 ioa_cfg
->sdt_state
= ABORT_DUMP
;
9298 if (ioa_cfg
->reset_retries
++ >= IPR_NUM_RESET_RELOAD_RETRIES
) {
9299 dev_err(&ioa_cfg
->pdev
->dev
,
9300 "IOA taken offline - error recovery failed\n");
9302 ioa_cfg
->reset_retries
= 0;
9303 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9304 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9305 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 1;
9306 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9310 if (ioa_cfg
->in_ioa_bringdown
) {
9311 ioa_cfg
->reset_cmd
= NULL
;
9312 ioa_cfg
->in_reset_reload
= 0;
9313 ipr_fail_all_ops(ioa_cfg
);
9314 wake_up_all(&ioa_cfg
->reset_wait_q
);
9316 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
) {
9317 ioa_cfg
->scsi_unblock
= 1;
9318 schedule_work(&ioa_cfg
->work_q
);
9322 ioa_cfg
->in_ioa_bringdown
= 1;
9323 shutdown_type
= IPR_SHUTDOWN_NONE
;
9327 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_shutdown_ioa
,
9332 * ipr_reset_freeze - Hold off all I/O activity
9333 * @ipr_cmd: ipr command struct
9335 * Description: If the PCI slot is frozen, hold off all I/O
9336 * activity; then, as soon as the slot is available again,
9337 * initiate an adapter reset.
9339 static int ipr_reset_freeze(struct ipr_cmnd
*ipr_cmd
)
9341 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9344 /* Disallow new interrupts, avoid loop */
9345 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9346 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9347 ioa_cfg
->hrrq
[i
].allow_interrupts
= 0;
9348 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9351 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
9352 ipr_cmd
->done
= ipr_reset_ioa_job
;
9353 return IPR_RC_JOB_RETURN
;
9357 * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9358 * @pdev: PCI device struct
9360 * Description: This routine is called to tell us that the MMIO
9361 * access to the IOA has been restored
9363 static pci_ers_result_t
ipr_pci_mmio_enabled(struct pci_dev
*pdev
)
9365 unsigned long flags
= 0;
9366 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9368 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9369 if (!ioa_cfg
->probe_done
)
9370 pci_save_state(pdev
);
9371 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9372 return PCI_ERS_RESULT_NEED_RESET
;
9376 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9377 * @pdev: PCI device struct
9379 * Description: This routine is called to tell us that the PCI bus
9380 * is down. Can't do anything here, except put the device driver
9381 * into a holding pattern, waiting for the PCI bus to come back.
9383 static void ipr_pci_frozen(struct pci_dev
*pdev
)
9385 unsigned long flags
= 0;
9386 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9388 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9389 if (ioa_cfg
->probe_done
)
9390 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_freeze
, IPR_SHUTDOWN_NONE
);
9391 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9395 * ipr_pci_slot_reset - Called when PCI slot has been reset.
9396 * @pdev: PCI device struct
9398 * Description: This routine is called by the pci error recovery
9399 * code after the PCI slot has been reset, just before we
9400 * should resume normal operations.
9402 static pci_ers_result_t
ipr_pci_slot_reset(struct pci_dev
*pdev
)
9404 unsigned long flags
= 0;
9405 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9407 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9408 if (ioa_cfg
->probe_done
) {
9409 if (ioa_cfg
->needs_warm_reset
)
9410 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9412 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_restore_cfg_space
,
9415 wake_up_all(&ioa_cfg
->eeh_wait_q
);
9416 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9417 return PCI_ERS_RESULT_RECOVERED
;
9421 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9422 * @pdev: PCI device struct
9424 * Description: This routine is called when the PCI bus has
9425 * permanently failed.
9427 static void ipr_pci_perm_failure(struct pci_dev
*pdev
)
9429 unsigned long flags
= 0;
9430 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9433 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9434 if (ioa_cfg
->probe_done
) {
9435 if (ioa_cfg
->sdt_state
== WAIT_FOR_DUMP
)
9436 ioa_cfg
->sdt_state
= ABORT_DUMP
;
9437 ioa_cfg
->reset_retries
= IPR_NUM_RESET_RELOAD_RETRIES
- 1;
9438 ioa_cfg
->in_ioa_bringdown
= 1;
9439 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9440 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9441 ioa_cfg
->hrrq
[i
].allow_cmds
= 0;
9442 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9445 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9447 wake_up_all(&ioa_cfg
->eeh_wait_q
);
9448 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9452 * ipr_pci_error_detected - Called when a PCI error is detected.
9453 * @pdev: PCI device struct
9454 * @state: PCI channel state
9456 * Description: Called when a PCI error is detected.
9459 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9461 static pci_ers_result_t
ipr_pci_error_detected(struct pci_dev
*pdev
,
9462 pci_channel_state_t state
)
9465 case pci_channel_io_frozen
:
9466 ipr_pci_frozen(pdev
);
9467 return PCI_ERS_RESULT_CAN_RECOVER
;
9468 case pci_channel_io_perm_failure
:
9469 ipr_pci_perm_failure(pdev
);
9470 return PCI_ERS_RESULT_DISCONNECT
;
9475 return PCI_ERS_RESULT_NEED_RESET
;
9479 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9480 * @ioa_cfg: ioa cfg struct
9482 * Description: This is the second phase of adapter initialization
9483 * This function takes care of initilizing the adapter to the point
9484 * where it can accept new commands.
9487 * 0 on success / -EIO on failure
9489 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg
*ioa_cfg
)
9492 unsigned long host_lock_flags
= 0;
9495 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
9496 dev_dbg(&ioa_cfg
->pdev
->dev
, "ioa_cfg adx: 0x%p\n", ioa_cfg
);
9497 ioa_cfg
->probe_done
= 1;
9498 if (ioa_cfg
->needs_hard_reset
) {
9499 ioa_cfg
->needs_hard_reset
= 0;
9500 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9502 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_enable_ioa
,
9504 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
9511 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9512 * @ioa_cfg: ioa config struct
9517 static void ipr_free_cmd_blks(struct ipr_ioa_cfg
*ioa_cfg
)
9521 if (ioa_cfg
->ipr_cmnd_list
) {
9522 for (i
= 0; i
< IPR_NUM_CMD_BLKS
; i
++) {
9523 if (ioa_cfg
->ipr_cmnd_list
[i
])
9524 dma_pool_free(ioa_cfg
->ipr_cmd_pool
,
9525 ioa_cfg
->ipr_cmnd_list
[i
],
9526 ioa_cfg
->ipr_cmnd_list_dma
[i
]);
9528 ioa_cfg
->ipr_cmnd_list
[i
] = NULL
;
9532 if (ioa_cfg
->ipr_cmd_pool
)
9533 dma_pool_destroy(ioa_cfg
->ipr_cmd_pool
);
9535 kfree(ioa_cfg
->ipr_cmnd_list
);
9536 kfree(ioa_cfg
->ipr_cmnd_list_dma
);
9537 ioa_cfg
->ipr_cmnd_list
= NULL
;
9538 ioa_cfg
->ipr_cmnd_list_dma
= NULL
;
9539 ioa_cfg
->ipr_cmd_pool
= NULL
;
9543 * ipr_free_mem - Frees memory allocated for an adapter
9544 * @ioa_cfg: ioa cfg struct
9549 static void ipr_free_mem(struct ipr_ioa_cfg
*ioa_cfg
)
9553 kfree(ioa_cfg
->res_entries
);
9554 dma_free_coherent(&ioa_cfg
->pdev
->dev
, sizeof(struct ipr_misc_cbs
),
9555 ioa_cfg
->vpd_cbs
, ioa_cfg
->vpd_cbs_dma
);
9556 ipr_free_cmd_blks(ioa_cfg
);
9558 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++)
9559 dma_free_coherent(&ioa_cfg
->pdev
->dev
,
9560 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9561 ioa_cfg
->hrrq
[i
].host_rrq
,
9562 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9564 dma_free_coherent(&ioa_cfg
->pdev
->dev
, ioa_cfg
->cfg_table_size
,
9565 ioa_cfg
->u
.cfg_table
, ioa_cfg
->cfg_table_dma
);
9567 for (i
= 0; i
< IPR_MAX_HCAMS
; i
++) {
9568 dma_free_coherent(&ioa_cfg
->pdev
->dev
,
9569 sizeof(struct ipr_hostrcb
),
9570 ioa_cfg
->hostrcb
[i
],
9571 ioa_cfg
->hostrcb_dma
[i
]);
9574 ipr_free_dump(ioa_cfg
);
9575 kfree(ioa_cfg
->trace
);
9579 * ipr_free_irqs - Free all allocated IRQs for the adapter.
9580 * @ioa_cfg: ipr cfg struct
9582 * This function frees all allocated IRQs for the
9583 * specified adapter.
9588 static void ipr_free_irqs(struct ipr_ioa_cfg
*ioa_cfg
)
9590 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9593 for (i
= 0; i
< ioa_cfg
->nvectors
; i
++)
9594 free_irq(pci_irq_vector(pdev
, i
), &ioa_cfg
->hrrq
[i
]);
9595 pci_free_irq_vectors(pdev
);
9599 * ipr_free_all_resources - Free all allocated resources for an adapter.
9600 * @ipr_cmd: ipr command struct
9602 * This function frees all allocated resources for the
9603 * specified adapter.
9608 static void ipr_free_all_resources(struct ipr_ioa_cfg
*ioa_cfg
)
9610 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9613 ipr_free_irqs(ioa_cfg
);
9614 if (ioa_cfg
->reset_work_q
)
9615 destroy_workqueue(ioa_cfg
->reset_work_q
);
9616 iounmap(ioa_cfg
->hdw_dma_regs
);
9617 pci_release_regions(pdev
);
9618 ipr_free_mem(ioa_cfg
);
9619 scsi_host_put(ioa_cfg
->host
);
9620 pci_disable_device(pdev
);
9625 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9626 * @ioa_cfg: ioa config struct
9629 * 0 on success / -ENOMEM on allocation failure
9631 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg
*ioa_cfg
)
9633 struct ipr_cmnd
*ipr_cmd
;
9634 struct ipr_ioarcb
*ioarcb
;
9635 dma_addr_t dma_addr
;
9636 int i
, entries_each_hrrq
, hrrq_id
= 0;
9638 ioa_cfg
->ipr_cmd_pool
= dma_pool_create(IPR_NAME
, &ioa_cfg
->pdev
->dev
,
9639 sizeof(struct ipr_cmnd
), 512, 0);
9641 if (!ioa_cfg
->ipr_cmd_pool
)
9644 ioa_cfg
->ipr_cmnd_list
= kcalloc(IPR_NUM_CMD_BLKS
, sizeof(struct ipr_cmnd
*), GFP_KERNEL
);
9645 ioa_cfg
->ipr_cmnd_list_dma
= kcalloc(IPR_NUM_CMD_BLKS
, sizeof(dma_addr_t
), GFP_KERNEL
);
9647 if (!ioa_cfg
->ipr_cmnd_list
|| !ioa_cfg
->ipr_cmnd_list_dma
) {
9648 ipr_free_cmd_blks(ioa_cfg
);
9652 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9653 if (ioa_cfg
->hrrq_num
> 1) {
9655 entries_each_hrrq
= IPR_NUM_INTERNAL_CMD_BLKS
;
9656 ioa_cfg
->hrrq
[i
].min_cmd_id
= 0;
9657 ioa_cfg
->hrrq
[i
].max_cmd_id
=
9658 (entries_each_hrrq
- 1);
9661 IPR_NUM_BASE_CMD_BLKS
/
9662 (ioa_cfg
->hrrq_num
- 1);
9663 ioa_cfg
->hrrq
[i
].min_cmd_id
=
9664 IPR_NUM_INTERNAL_CMD_BLKS
+
9665 (i
- 1) * entries_each_hrrq
;
9666 ioa_cfg
->hrrq
[i
].max_cmd_id
=
9667 (IPR_NUM_INTERNAL_CMD_BLKS
+
9668 i
* entries_each_hrrq
- 1);
9671 entries_each_hrrq
= IPR_NUM_CMD_BLKS
;
9672 ioa_cfg
->hrrq
[i
].min_cmd_id
= 0;
9673 ioa_cfg
->hrrq
[i
].max_cmd_id
= (entries_each_hrrq
- 1);
9675 ioa_cfg
->hrrq
[i
].size
= entries_each_hrrq
;
9678 BUG_ON(ioa_cfg
->hrrq_num
== 0);
9680 i
= IPR_NUM_CMD_BLKS
-
9681 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].max_cmd_id
- 1;
9683 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].size
+= i
;
9684 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].max_cmd_id
+= i
;
9687 for (i
= 0; i
< IPR_NUM_CMD_BLKS
; i
++) {
9688 ipr_cmd
= dma_pool_zalloc(ioa_cfg
->ipr_cmd_pool
,
9689 GFP_KERNEL
, &dma_addr
);
9692 ipr_free_cmd_blks(ioa_cfg
);
9696 ioa_cfg
->ipr_cmnd_list
[i
] = ipr_cmd
;
9697 ioa_cfg
->ipr_cmnd_list_dma
[i
] = dma_addr
;
9699 ioarcb
= &ipr_cmd
->ioarcb
;
9700 ipr_cmd
->dma_addr
= dma_addr
;
9702 ioarcb
->a
.ioarcb_host_pci_addr64
= cpu_to_be64(dma_addr
);
9704 ioarcb
->a
.ioarcb_host_pci_addr
= cpu_to_be32(dma_addr
);
9706 ioarcb
->host_response_handle
= cpu_to_be32(i
<< 2);
9707 if (ioa_cfg
->sis64
) {
9708 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
9709 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl64
));
9710 ioarcb
->u
.sis64_addr_data
.ioasa_host_pci_addr
=
9711 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, s
.ioasa64
));
9713 ioarcb
->write_ioadl_addr
=
9714 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl
));
9715 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
9716 ioarcb
->ioasa_host_pci_addr
=
9717 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, s
.ioasa
));
9719 ioarcb
->ioasa_len
= cpu_to_be16(sizeof(struct ipr_ioasa
));
9720 ipr_cmd
->cmd_index
= i
;
9721 ipr_cmd
->ioa_cfg
= ioa_cfg
;
9722 ipr_cmd
->sense_buffer_dma
= dma_addr
+
9723 offsetof(struct ipr_cmnd
, sense_buffer
);
9725 ipr_cmd
->ioarcb
.cmd_pkt
.hrrq_id
= hrrq_id
;
9726 ipr_cmd
->hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
9727 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
9728 if (i
>= ioa_cfg
->hrrq
[hrrq_id
].max_cmd_id
)
9736 * ipr_alloc_mem - Allocate memory for an adapter
9737 * @ioa_cfg: ioa config struct
9740 * 0 on success / non-zero for error
9742 static int ipr_alloc_mem(struct ipr_ioa_cfg
*ioa_cfg
)
9744 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9745 int i
, rc
= -ENOMEM
;
9748 ioa_cfg
->res_entries
= kcalloc(ioa_cfg
->max_devs_supported
,
9749 sizeof(struct ipr_resource_entry
),
9752 if (!ioa_cfg
->res_entries
)
9755 for (i
= 0; i
< ioa_cfg
->max_devs_supported
; i
++) {
9756 list_add_tail(&ioa_cfg
->res_entries
[i
].queue
, &ioa_cfg
->free_res_q
);
9757 ioa_cfg
->res_entries
[i
].ioa_cfg
= ioa_cfg
;
9760 ioa_cfg
->vpd_cbs
= dma_alloc_coherent(&pdev
->dev
,
9761 sizeof(struct ipr_misc_cbs
),
9762 &ioa_cfg
->vpd_cbs_dma
,
9765 if (!ioa_cfg
->vpd_cbs
)
9766 goto out_free_res_entries
;
9768 if (ipr_alloc_cmd_blks(ioa_cfg
))
9769 goto out_free_vpd_cbs
;
9771 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9772 ioa_cfg
->hrrq
[i
].host_rrq
= dma_alloc_coherent(&pdev
->dev
,
9773 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9774 &ioa_cfg
->hrrq
[i
].host_rrq_dma
,
9777 if (!ioa_cfg
->hrrq
[i
].host_rrq
) {
9779 dma_free_coherent(&pdev
->dev
,
9780 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9781 ioa_cfg
->hrrq
[i
].host_rrq
,
9782 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9783 goto out_ipr_free_cmd_blocks
;
9785 ioa_cfg
->hrrq
[i
].ioa_cfg
= ioa_cfg
;
9788 ioa_cfg
->u
.cfg_table
= dma_alloc_coherent(&pdev
->dev
,
9789 ioa_cfg
->cfg_table_size
,
9790 &ioa_cfg
->cfg_table_dma
,
9793 if (!ioa_cfg
->u
.cfg_table
)
9794 goto out_free_host_rrq
;
9796 for (i
= 0; i
< IPR_MAX_HCAMS
; i
++) {
9797 ioa_cfg
->hostrcb
[i
] = dma_alloc_coherent(&pdev
->dev
,
9798 sizeof(struct ipr_hostrcb
),
9799 &ioa_cfg
->hostrcb_dma
[i
],
9802 if (!ioa_cfg
->hostrcb
[i
])
9803 goto out_free_hostrcb_dma
;
9805 ioa_cfg
->hostrcb
[i
]->hostrcb_dma
=
9806 ioa_cfg
->hostrcb_dma
[i
] + offsetof(struct ipr_hostrcb
, hcam
);
9807 ioa_cfg
->hostrcb
[i
]->ioa_cfg
= ioa_cfg
;
9808 list_add_tail(&ioa_cfg
->hostrcb
[i
]->queue
, &ioa_cfg
->hostrcb_free_q
);
9811 ioa_cfg
->trace
= kcalloc(IPR_NUM_TRACE_ENTRIES
,
9812 sizeof(struct ipr_trace_entry
),
9815 if (!ioa_cfg
->trace
)
9816 goto out_free_hostrcb_dma
;
9823 out_free_hostrcb_dma
:
9825 dma_free_coherent(&pdev
->dev
, sizeof(struct ipr_hostrcb
),
9826 ioa_cfg
->hostrcb
[i
],
9827 ioa_cfg
->hostrcb_dma
[i
]);
9829 dma_free_coherent(&pdev
->dev
, ioa_cfg
->cfg_table_size
,
9830 ioa_cfg
->u
.cfg_table
, ioa_cfg
->cfg_table_dma
);
9832 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9833 dma_free_coherent(&pdev
->dev
,
9834 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9835 ioa_cfg
->hrrq
[i
].host_rrq
,
9836 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9838 out_ipr_free_cmd_blocks
:
9839 ipr_free_cmd_blks(ioa_cfg
);
9841 dma_free_coherent(&pdev
->dev
, sizeof(struct ipr_misc_cbs
),
9842 ioa_cfg
->vpd_cbs
, ioa_cfg
->vpd_cbs_dma
);
9843 out_free_res_entries
:
9844 kfree(ioa_cfg
->res_entries
);
9849 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9850 * @ioa_cfg: ioa config struct
9855 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg
*ioa_cfg
)
9859 for (i
= 0; i
< IPR_MAX_NUM_BUSES
; i
++) {
9860 ioa_cfg
->bus_attr
[i
].bus
= i
;
9861 ioa_cfg
->bus_attr
[i
].qas_enabled
= 0;
9862 ioa_cfg
->bus_attr
[i
].bus_width
= IPR_DEFAULT_BUS_WIDTH
;
9863 if (ipr_max_speed
< ARRAY_SIZE(ipr_max_bus_speeds
))
9864 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= ipr_max_bus_speeds
[ipr_max_speed
];
9866 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= IPR_U160_SCSI_RATE
;
9871 * ipr_init_regs - Initialize IOA registers
9872 * @ioa_cfg: ioa config struct
9877 static void ipr_init_regs(struct ipr_ioa_cfg
*ioa_cfg
)
9879 const struct ipr_interrupt_offsets
*p
;
9880 struct ipr_interrupts
*t
;
9883 p
= &ioa_cfg
->chip_cfg
->regs
;
9885 base
= ioa_cfg
->hdw_dma_regs
;
9887 t
->set_interrupt_mask_reg
= base
+ p
->set_interrupt_mask_reg
;
9888 t
->clr_interrupt_mask_reg
= base
+ p
->clr_interrupt_mask_reg
;
9889 t
->clr_interrupt_mask_reg32
= base
+ p
->clr_interrupt_mask_reg32
;
9890 t
->sense_interrupt_mask_reg
= base
+ p
->sense_interrupt_mask_reg
;
9891 t
->sense_interrupt_mask_reg32
= base
+ p
->sense_interrupt_mask_reg32
;
9892 t
->clr_interrupt_reg
= base
+ p
->clr_interrupt_reg
;
9893 t
->clr_interrupt_reg32
= base
+ p
->clr_interrupt_reg32
;
9894 t
->sense_interrupt_reg
= base
+ p
->sense_interrupt_reg
;
9895 t
->sense_interrupt_reg32
= base
+ p
->sense_interrupt_reg32
;
9896 t
->ioarrin_reg
= base
+ p
->ioarrin_reg
;
9897 t
->sense_uproc_interrupt_reg
= base
+ p
->sense_uproc_interrupt_reg
;
9898 t
->sense_uproc_interrupt_reg32
= base
+ p
->sense_uproc_interrupt_reg32
;
9899 t
->set_uproc_interrupt_reg
= base
+ p
->set_uproc_interrupt_reg
;
9900 t
->set_uproc_interrupt_reg32
= base
+ p
->set_uproc_interrupt_reg32
;
9901 t
->clr_uproc_interrupt_reg
= base
+ p
->clr_uproc_interrupt_reg
;
9902 t
->clr_uproc_interrupt_reg32
= base
+ p
->clr_uproc_interrupt_reg32
;
9904 if (ioa_cfg
->sis64
) {
9905 t
->init_feedback_reg
= base
+ p
->init_feedback_reg
;
9906 t
->dump_addr_reg
= base
+ p
->dump_addr_reg
;
9907 t
->dump_data_reg
= base
+ p
->dump_data_reg
;
9908 t
->endian_swap_reg
= base
+ p
->endian_swap_reg
;
9913 * ipr_init_ioa_cfg - Initialize IOA config struct
9914 * @ioa_cfg: ioa config struct
9915 * @host: scsi host struct
9916 * @pdev: PCI dev struct
9921 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg
*ioa_cfg
,
9922 struct Scsi_Host
*host
, struct pci_dev
*pdev
)
9926 ioa_cfg
->host
= host
;
9927 ioa_cfg
->pdev
= pdev
;
9928 ioa_cfg
->log_level
= ipr_log_level
;
9929 ioa_cfg
->doorbell
= IPR_DOORBELL
;
9930 sprintf(ioa_cfg
->eye_catcher
, IPR_EYECATCHER
);
9931 sprintf(ioa_cfg
->trace_start
, IPR_TRACE_START_LABEL
);
9932 sprintf(ioa_cfg
->cfg_table_start
, IPR_CFG_TBL_START
);
9933 sprintf(ioa_cfg
->resource_table_label
, IPR_RES_TABLE_LABEL
);
9934 sprintf(ioa_cfg
->ipr_hcam_label
, IPR_HCAM_LABEL
);
9935 sprintf(ioa_cfg
->ipr_cmd_label
, IPR_CMD_LABEL
);
9937 INIT_LIST_HEAD(&ioa_cfg
->hostrcb_free_q
);
9938 INIT_LIST_HEAD(&ioa_cfg
->hostrcb_pending_q
);
9939 INIT_LIST_HEAD(&ioa_cfg
->hostrcb_report_q
);
9940 INIT_LIST_HEAD(&ioa_cfg
->free_res_q
);
9941 INIT_LIST_HEAD(&ioa_cfg
->used_res_q
);
9942 INIT_WORK(&ioa_cfg
->work_q
, ipr_worker_thread
);
9943 INIT_WORK(&ioa_cfg
->scsi_add_work_q
, ipr_add_remove_thread
);
9944 init_waitqueue_head(&ioa_cfg
->reset_wait_q
);
9945 init_waitqueue_head(&ioa_cfg
->msi_wait_q
);
9946 init_waitqueue_head(&ioa_cfg
->eeh_wait_q
);
9947 ioa_cfg
->sdt_state
= INACTIVE
;
9949 ipr_initialize_bus_attr(ioa_cfg
);
9950 ioa_cfg
->max_devs_supported
= ipr_max_devs
;
9952 if (ioa_cfg
->sis64
) {
9953 host
->max_channel
= IPR_MAX_SIS64_BUSES
;
9954 host
->max_id
= IPR_MAX_SIS64_TARGETS_PER_BUS
;
9955 host
->max_lun
= IPR_MAX_SIS64_LUNS_PER_TARGET
;
9956 if (ipr_max_devs
> IPR_MAX_SIS64_DEVS
)
9957 ioa_cfg
->max_devs_supported
= IPR_MAX_SIS64_DEVS
;
9958 ioa_cfg
->cfg_table_size
= (sizeof(struct ipr_config_table_hdr64
)
9959 + ((sizeof(struct ipr_config_table_entry64
)
9960 * ioa_cfg
->max_devs_supported
)));
9962 host
->max_channel
= IPR_VSET_BUS
;
9963 host
->max_id
= IPR_MAX_NUM_TARGETS_PER_BUS
;
9964 host
->max_lun
= IPR_MAX_NUM_LUNS_PER_TARGET
;
9965 if (ipr_max_devs
> IPR_MAX_PHYSICAL_DEVS
)
9966 ioa_cfg
->max_devs_supported
= IPR_MAX_PHYSICAL_DEVS
;
9967 ioa_cfg
->cfg_table_size
= (sizeof(struct ipr_config_table_hdr
)
9968 + ((sizeof(struct ipr_config_table_entry
)
9969 * ioa_cfg
->max_devs_supported
)));
9972 host
->unique_id
= host
->host_no
;
9973 host
->max_cmd_len
= IPR_MAX_CDB_LEN
;
9974 host
->can_queue
= ioa_cfg
->max_cmds
;
9975 pci_set_drvdata(pdev
, ioa_cfg
);
9977 for (i
= 0; i
< ARRAY_SIZE(ioa_cfg
->hrrq
); i
++) {
9978 INIT_LIST_HEAD(&ioa_cfg
->hrrq
[i
].hrrq_free_q
);
9979 INIT_LIST_HEAD(&ioa_cfg
->hrrq
[i
].hrrq_pending_q
);
9980 spin_lock_init(&ioa_cfg
->hrrq
[i
]._lock
);
9982 ioa_cfg
->hrrq
[i
].lock
= ioa_cfg
->host
->host_lock
;
9984 ioa_cfg
->hrrq
[i
].lock
= &ioa_cfg
->hrrq
[i
]._lock
;
9989 * ipr_get_chip_info - Find adapter chip information
9990 * @dev_id: PCI device id struct
9993 * ptr to chip information on success / NULL on failure
9995 static const struct ipr_chip_t
*
9996 ipr_get_chip_info(const struct pci_device_id
*dev_id
)
10000 for (i
= 0; i
< ARRAY_SIZE(ipr_chip
); i
++)
10001 if (ipr_chip
[i
].vendor
== dev_id
->vendor
&&
10002 ipr_chip
[i
].device
== dev_id
->device
)
10003 return &ipr_chip
[i
];
10008 * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
10009 * during probe time
10010 * @ioa_cfg: ioa config struct
10015 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg
*ioa_cfg
)
10017 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
10019 if (pci_channel_offline(pdev
)) {
10020 wait_event_timeout(ioa_cfg
->eeh_wait_q
,
10021 !pci_channel_offline(pdev
),
10022 IPR_PCI_ERROR_RECOVERY_TIMEOUT
);
10023 pci_restore_state(pdev
);
10027 static void name_msi_vectors(struct ipr_ioa_cfg
*ioa_cfg
)
10029 int vec_idx
, n
= sizeof(ioa_cfg
->vectors_info
[0].desc
) - 1;
10031 for (vec_idx
= 0; vec_idx
< ioa_cfg
->nvectors
; vec_idx
++) {
10032 snprintf(ioa_cfg
->vectors_info
[vec_idx
].desc
, n
,
10033 "host%d-%d", ioa_cfg
->host
->host_no
, vec_idx
);
10034 ioa_cfg
->vectors_info
[vec_idx
].
10035 desc
[strlen(ioa_cfg
->vectors_info
[vec_idx
].desc
)] = 0;
10039 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg
*ioa_cfg
,
10040 struct pci_dev
*pdev
)
10044 for (i
= 1; i
< ioa_cfg
->nvectors
; i
++) {
10045 rc
= request_irq(pci_irq_vector(pdev
, i
),
10048 ioa_cfg
->vectors_info
[i
].desc
,
10049 &ioa_cfg
->hrrq
[i
]);
10052 free_irq(pci_irq_vector(pdev
, i
),
10053 &ioa_cfg
->hrrq
[i
]);
10061 * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
10062 * @pdev: PCI device struct
10064 * Description: Simply set the msi_received flag to 1 indicating that
10065 * Message Signaled Interrupts are supported.
10068 * 0 on success / non-zero on failure
10070 static irqreturn_t
ipr_test_intr(int irq
, void *devp
)
10072 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)devp
;
10073 unsigned long lock_flags
= 0;
10074 irqreturn_t rc
= IRQ_HANDLED
;
10076 dev_info(&ioa_cfg
->pdev
->dev
, "Received IRQ : %d\n", irq
);
10077 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10079 ioa_cfg
->msi_received
= 1;
10080 wake_up(&ioa_cfg
->msi_wait_q
);
10082 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10087 * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
10088 * @pdev: PCI device struct
10090 * Description: This routine sets up and initiates a test interrupt to determine
10091 * if the interrupt is received via the ipr_test_intr() service routine.
10092 * If the tests fails, the driver will fall back to LSI.
10095 * 0 on success / non-zero on failure
10097 static int ipr_test_msi(struct ipr_ioa_cfg
*ioa_cfg
, struct pci_dev
*pdev
)
10100 volatile u32 int_reg
;
10101 unsigned long lock_flags
= 0;
10102 int irq
= pci_irq_vector(pdev
, 0);
10106 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10107 init_waitqueue_head(&ioa_cfg
->msi_wait_q
);
10108 ioa_cfg
->msi_received
= 0;
10109 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
10110 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
, ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
10111 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
10112 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10114 rc
= request_irq(irq
, ipr_test_intr
, 0, IPR_NAME
, ioa_cfg
);
10116 dev_err(&pdev
->dev
, "Can not assign irq %d\n", irq
);
10118 } else if (ipr_debug
)
10119 dev_info(&pdev
->dev
, "IRQ assigned: %d\n", irq
);
10121 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
, ioa_cfg
->regs
.sense_interrupt_reg32
);
10122 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
10123 wait_event_timeout(ioa_cfg
->msi_wait_q
, ioa_cfg
->msi_received
, HZ
);
10124 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10125 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
10127 if (!ioa_cfg
->msi_received
) {
10128 /* MSI test failed */
10129 dev_info(&pdev
->dev
, "MSI test failed. Falling back to LSI.\n");
10131 } else if (ipr_debug
)
10132 dev_info(&pdev
->dev
, "MSI test succeeded.\n");
10134 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10136 free_irq(irq
, ioa_cfg
);
10143 /* ipr_probe_ioa - Allocates memory and does first stage of initialization
10144 * @pdev: PCI device struct
10145 * @dev_id: PCI device id struct
10148 * 0 on success / non-zero on failure
10150 static int ipr_probe_ioa(struct pci_dev
*pdev
,
10151 const struct pci_device_id
*dev_id
)
10153 struct ipr_ioa_cfg
*ioa_cfg
;
10154 struct Scsi_Host
*host
;
10155 unsigned long ipr_regs_pci
;
10156 void __iomem
*ipr_regs
;
10157 int rc
= PCIBIOS_SUCCESSFUL
;
10158 volatile u32 mask
, uproc
, interrupts
;
10159 unsigned long lock_flags
, driver_lock_flags
;
10160 unsigned int irq_flag
;
10164 dev_info(&pdev
->dev
, "Found IOA with IRQ: %d\n", pdev
->irq
);
10165 host
= scsi_host_alloc(&driver_template
, sizeof(*ioa_cfg
));
10168 dev_err(&pdev
->dev
, "call to scsi_host_alloc failed!\n");
10173 ioa_cfg
= (struct ipr_ioa_cfg
*)host
->hostdata
;
10174 memset(ioa_cfg
, 0, sizeof(struct ipr_ioa_cfg
));
10175 ata_host_init(&ioa_cfg
->ata_host
, &pdev
->dev
, &ipr_sata_ops
);
10177 ioa_cfg
->ipr_chip
= ipr_get_chip_info(dev_id
);
10179 if (!ioa_cfg
->ipr_chip
) {
10180 dev_err(&pdev
->dev
, "Unknown adapter chipset 0x%04X 0x%04X\n",
10181 dev_id
->vendor
, dev_id
->device
);
10182 goto out_scsi_host_put
;
10185 /* set SIS 32 or SIS 64 */
10186 ioa_cfg
->sis64
= ioa_cfg
->ipr_chip
->sis_type
== IPR_SIS64
? 1 : 0;
10187 ioa_cfg
->chip_cfg
= ioa_cfg
->ipr_chip
->cfg
;
10188 ioa_cfg
->clear_isr
= ioa_cfg
->chip_cfg
->clear_isr
;
10189 ioa_cfg
->max_cmds
= ioa_cfg
->chip_cfg
->max_cmds
;
10191 if (ipr_transop_timeout
)
10192 ioa_cfg
->transop_timeout
= ipr_transop_timeout
;
10193 else if (dev_id
->driver_data
& IPR_USE_LONG_TRANSOP_TIMEOUT
)
10194 ioa_cfg
->transop_timeout
= IPR_LONG_OPERATIONAL_TIMEOUT
;
10196 ioa_cfg
->transop_timeout
= IPR_OPERATIONAL_TIMEOUT
;
10198 ioa_cfg
->revid
= pdev
->revision
;
10200 ipr_init_ioa_cfg(ioa_cfg
, host
, pdev
);
10202 ipr_regs_pci
= pci_resource_start(pdev
, 0);
10204 rc
= pci_request_regions(pdev
, IPR_NAME
);
10206 dev_err(&pdev
->dev
,
10207 "Couldn't register memory range of registers\n");
10208 goto out_scsi_host_put
;
10211 rc
= pci_enable_device(pdev
);
10213 if (rc
|| pci_channel_offline(pdev
)) {
10214 if (pci_channel_offline(pdev
)) {
10215 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10216 rc
= pci_enable_device(pdev
);
10220 dev_err(&pdev
->dev
, "Cannot enable adapter\n");
10221 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10222 goto out_release_regions
;
10226 ipr_regs
= pci_ioremap_bar(pdev
, 0);
10229 dev_err(&pdev
->dev
,
10230 "Couldn't map memory range of registers\n");
10235 ioa_cfg
->hdw_dma_regs
= ipr_regs
;
10236 ioa_cfg
->hdw_dma_regs_pci
= ipr_regs_pci
;
10237 ioa_cfg
->ioa_mailbox
= ioa_cfg
->chip_cfg
->mailbox
+ ipr_regs
;
10239 ipr_init_regs(ioa_cfg
);
10241 if (ioa_cfg
->sis64
) {
10242 rc
= dma_set_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(64));
10244 dev_dbg(&pdev
->dev
, "Failed to set 64 bit DMA mask\n");
10245 rc
= dma_set_mask_and_coherent(&pdev
->dev
,
10249 rc
= dma_set_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
10252 dev_err(&pdev
->dev
, "Failed to set DMA mask\n");
10253 goto cleanup_nomem
;
10256 rc
= pci_write_config_byte(pdev
, PCI_CACHE_LINE_SIZE
,
10257 ioa_cfg
->chip_cfg
->cache_line_size
);
10259 if (rc
!= PCIBIOS_SUCCESSFUL
) {
10260 dev_err(&pdev
->dev
, "Write of cache line size failed\n");
10261 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10263 goto cleanup_nomem
;
10266 /* Issue MMIO read to ensure card is not in EEH */
10267 interrupts
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
10268 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10270 if (ipr_number_of_msix
> IPR_MAX_MSIX_VECTORS
) {
10271 dev_err(&pdev
->dev
, "The max number of MSIX is %d\n",
10272 IPR_MAX_MSIX_VECTORS
);
10273 ipr_number_of_msix
= IPR_MAX_MSIX_VECTORS
;
10276 irq_flag
= PCI_IRQ_LEGACY
;
10277 if (ioa_cfg
->ipr_chip
->has_msi
)
10278 irq_flag
|= PCI_IRQ_MSI
| PCI_IRQ_MSIX
;
10279 rc
= pci_alloc_irq_vectors(pdev
, 1, ipr_number_of_msix
, irq_flag
);
10281 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10282 goto cleanup_nomem
;
10284 ioa_cfg
->nvectors
= rc
;
10286 if (!pdev
->msi_enabled
&& !pdev
->msix_enabled
)
10287 ioa_cfg
->clear_isr
= 1;
10289 pci_set_master(pdev
);
10291 if (pci_channel_offline(pdev
)) {
10292 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10293 pci_set_master(pdev
);
10294 if (pci_channel_offline(pdev
)) {
10296 goto out_msi_disable
;
10300 if (pdev
->msi_enabled
|| pdev
->msix_enabled
) {
10301 rc
= ipr_test_msi(ioa_cfg
, pdev
);
10304 dev_info(&pdev
->dev
,
10305 "Request for %d MSI%ss succeeded.", ioa_cfg
->nvectors
,
10306 pdev
->msix_enabled
? "-X" : "");
10309 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10310 pci_free_irq_vectors(pdev
);
10312 ioa_cfg
->nvectors
= 1;
10313 ioa_cfg
->clear_isr
= 1;
10316 goto out_msi_disable
;
10320 ioa_cfg
->hrrq_num
= min3(ioa_cfg
->nvectors
,
10321 (unsigned int)num_online_cpus(),
10322 (unsigned int)IPR_MAX_HRRQ_NUM
);
10324 if ((rc
= ipr_save_pcix_cmd_reg(ioa_cfg
)))
10325 goto out_msi_disable
;
10327 if ((rc
= ipr_set_pcix_cmd_reg(ioa_cfg
)))
10328 goto out_msi_disable
;
10330 rc
= ipr_alloc_mem(ioa_cfg
);
10332 dev_err(&pdev
->dev
,
10333 "Couldn't allocate enough memory for device driver!\n");
10334 goto out_msi_disable
;
10337 /* Save away PCI config space for use following IOA reset */
10338 rc
= pci_save_state(pdev
);
10340 if (rc
!= PCIBIOS_SUCCESSFUL
) {
10341 dev_err(&pdev
->dev
, "Failed to save PCI config space\n");
10343 goto cleanup_nolog
;
10347 * If HRRQ updated interrupt is not masked, or reset alert is set,
10348 * the card is in an unknown state and needs a hard reset
10350 mask
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg32
);
10351 interrupts
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
10352 uproc
= readl(ioa_cfg
->regs
.sense_uproc_interrupt_reg32
);
10353 if ((mask
& IPR_PCII_HRRQ_UPDATED
) == 0 || (uproc
& IPR_UPROCI_RESET_ALERT
))
10354 ioa_cfg
->needs_hard_reset
= 1;
10355 if ((interrupts
& IPR_PCII_ERROR_INTERRUPTS
) || reset_devices
)
10356 ioa_cfg
->needs_hard_reset
= 1;
10357 if (interrupts
& IPR_PCII_IOA_UNIT_CHECKED
)
10358 ioa_cfg
->ioa_unit_checked
= 1;
10360 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10361 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
10362 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10364 if (pdev
->msi_enabled
|| pdev
->msix_enabled
) {
10365 name_msi_vectors(ioa_cfg
);
10366 rc
= request_irq(pci_irq_vector(pdev
, 0), ipr_isr
, 0,
10367 ioa_cfg
->vectors_info
[0].desc
,
10368 &ioa_cfg
->hrrq
[0]);
10370 rc
= ipr_request_other_msi_irqs(ioa_cfg
, pdev
);
10372 rc
= request_irq(pdev
->irq
, ipr_isr
,
10374 IPR_NAME
, &ioa_cfg
->hrrq
[0]);
10377 dev_err(&pdev
->dev
, "Couldn't register IRQ %d! rc=%d\n",
10379 goto cleanup_nolog
;
10382 if ((dev_id
->driver_data
& IPR_USE_PCI_WARM_RESET
) ||
10383 (dev_id
->device
== PCI_DEVICE_ID_IBM_OBSIDIAN_E
&& !ioa_cfg
->revid
)) {
10384 ioa_cfg
->needs_warm_reset
= 1;
10385 ioa_cfg
->reset
= ipr_reset_slot_reset
;
10387 ioa_cfg
->reset_work_q
= alloc_ordered_workqueue("ipr_reset_%d",
10388 WQ_MEM_RECLAIM
, host
->host_no
);
10390 if (!ioa_cfg
->reset_work_q
) {
10391 dev_err(&pdev
->dev
, "Couldn't register reset workqueue\n");
10396 ioa_cfg
->reset
= ipr_reset_start_bist
;
10398 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10399 list_add_tail(&ioa_cfg
->queue
, &ipr_ioa_head
);
10400 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10407 ipr_free_irqs(ioa_cfg
);
10409 ipr_free_mem(ioa_cfg
);
10411 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10412 pci_free_irq_vectors(pdev
);
10416 pci_disable_device(pdev
);
10417 out_release_regions
:
10418 pci_release_regions(pdev
);
10420 scsi_host_put(host
);
10425 * ipr_initiate_ioa_bringdown - Bring down an adapter
10426 * @ioa_cfg: ioa config struct
10427 * @shutdown_type: shutdown type
10429 * Description: This function will initiate bringing down the adapter.
10430 * This consists of issuing an IOA shutdown to the adapter
10431 * to flush the cache, and running BIST.
10432 * If the caller needs to wait on the completion of the reset,
10433 * the caller must sleep on the reset_wait_q.
10438 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg
*ioa_cfg
,
10439 enum ipr_shutdown_type shutdown_type
)
10442 if (ioa_cfg
->sdt_state
== WAIT_FOR_DUMP
)
10443 ioa_cfg
->sdt_state
= ABORT_DUMP
;
10444 ioa_cfg
->reset_retries
= 0;
10445 ioa_cfg
->in_ioa_bringdown
= 1;
10446 ipr_initiate_ioa_reset(ioa_cfg
, shutdown_type
);
10451 * __ipr_remove - Remove a single adapter
10452 * @pdev: pci device struct
10454 * Adapter hot plug remove entry point.
10459 static void __ipr_remove(struct pci_dev
*pdev
)
10461 unsigned long host_lock_flags
= 0;
10462 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10464 unsigned long driver_lock_flags
;
10467 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10468 while (ioa_cfg
->in_reset_reload
) {
10469 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10470 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10471 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10474 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
10475 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
10476 ioa_cfg
->hrrq
[i
].removing_ioa
= 1;
10477 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
10480 ipr_initiate_ioa_bringdown(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
10482 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10483 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10484 flush_work(&ioa_cfg
->work_q
);
10485 if (ioa_cfg
->reset_work_q
)
10486 flush_workqueue(ioa_cfg
->reset_work_q
);
10487 INIT_LIST_HEAD(&ioa_cfg
->used_res_q
);
10488 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10490 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10491 list_del(&ioa_cfg
->queue
);
10492 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10494 if (ioa_cfg
->sdt_state
== ABORT_DUMP
)
10495 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
10496 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10498 ipr_free_all_resources(ioa_cfg
);
10504 * ipr_remove - IOA hot plug remove entry point
10505 * @pdev: pci device struct
10507 * Adapter hot plug remove entry point.
10512 static void ipr_remove(struct pci_dev
*pdev
)
10514 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10518 ipr_remove_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10520 ipr_remove_dump_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10522 sysfs_remove_bin_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10523 &ipr_ioa_async_err_log
);
10524 scsi_remove_host(ioa_cfg
->host
);
10526 __ipr_remove(pdev
);
10532 * ipr_probe - Adapter hot plug add entry point
10535 * 0 on success / non-zero on failure
10537 static int ipr_probe(struct pci_dev
*pdev
, const struct pci_device_id
*dev_id
)
10539 struct ipr_ioa_cfg
*ioa_cfg
;
10540 unsigned long flags
;
10543 rc
= ipr_probe_ioa(pdev
, dev_id
);
10548 ioa_cfg
= pci_get_drvdata(pdev
);
10549 rc
= ipr_probe_ioa_part2(ioa_cfg
);
10552 __ipr_remove(pdev
);
10556 rc
= scsi_add_host(ioa_cfg
->host
, &pdev
->dev
);
10559 __ipr_remove(pdev
);
10563 rc
= ipr_create_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10567 scsi_remove_host(ioa_cfg
->host
);
10568 __ipr_remove(pdev
);
10572 rc
= sysfs_create_bin_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10573 &ipr_ioa_async_err_log
);
10576 ipr_remove_dump_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10578 ipr_remove_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10580 scsi_remove_host(ioa_cfg
->host
);
10581 __ipr_remove(pdev
);
10585 rc
= ipr_create_dump_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10589 sysfs_remove_bin_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10590 &ipr_ioa_async_err_log
);
10591 ipr_remove_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10593 scsi_remove_host(ioa_cfg
->host
);
10594 __ipr_remove(pdev
);
10597 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
10598 ioa_cfg
->scan_enabled
= 1;
10599 schedule_work(&ioa_cfg
->work_q
);
10600 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
10602 ioa_cfg
->iopoll_weight
= ioa_cfg
->chip_cfg
->iopoll_weight
;
10604 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
10605 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++) {
10606 irq_poll_init(&ioa_cfg
->hrrq
[i
].iopoll
,
10607 ioa_cfg
->iopoll_weight
, ipr_iopoll
);
10611 scsi_scan_host(ioa_cfg
->host
);
10617 * ipr_shutdown - Shutdown handler.
10618 * @pdev: pci device struct
10620 * This function is invoked upon system shutdown/reboot. It will issue
10621 * an adapter shutdown to the adapter to flush the write cache.
10626 static void ipr_shutdown(struct pci_dev
*pdev
)
10628 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10629 unsigned long lock_flags
= 0;
10630 enum ipr_shutdown_type shutdown_type
= IPR_SHUTDOWN_NORMAL
;
10633 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10634 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
10635 ioa_cfg
->iopoll_weight
= 0;
10636 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++)
10637 irq_poll_disable(&ioa_cfg
->hrrq
[i
].iopoll
);
10640 while (ioa_cfg
->in_reset_reload
) {
10641 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10642 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10643 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10646 if (ipr_fast_reboot
&& system_state
== SYSTEM_RESTART
&& ioa_cfg
->sis64
)
10647 shutdown_type
= IPR_SHUTDOWN_QUIESCE
;
10649 ipr_initiate_ioa_bringdown(ioa_cfg
, shutdown_type
);
10650 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10651 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10652 if (ipr_fast_reboot
&& system_state
== SYSTEM_RESTART
&& ioa_cfg
->sis64
) {
10653 ipr_free_irqs(ioa_cfg
);
10654 pci_disable_device(ioa_cfg
->pdev
);
10658 static struct pci_device_id ipr_pci_table
[] = {
10659 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10660 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_5702
, 0, 0, 0 },
10661 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10662 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_5703
, 0, 0, 0 },
10663 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10664 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_573D
, 0, 0, 0 },
10665 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10666 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_573E
, 0, 0, 0 },
10667 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10668 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571B
, 0, 0, 0 },
10669 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10670 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572E
, 0, 0, 0 },
10671 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10672 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571A
, 0, 0, 0 },
10673 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10674 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575B
, 0, 0,
10675 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10676 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10677 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572A
, 0, 0, 0 },
10678 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10679 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572B
, 0, 0,
10680 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10681 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10682 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575C
, 0, 0,
10683 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10684 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10685 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572A
, 0, 0, 0 },
10686 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10687 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572B
, 0, 0,
10688 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10689 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10690 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575C
, 0, 0,
10691 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10692 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10693 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_574E
, 0, 0,
10694 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10695 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10696 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B3
, 0, 0, 0 },
10697 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10698 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57CC
, 0, 0, 0 },
10699 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10700 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B7
, 0, 0,
10701 IPR_USE_LONG_TRANSOP_TIMEOUT
| IPR_USE_PCI_WARM_RESET
},
10702 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_SNIPE
,
10703 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2780
, 0, 0, 0 },
10704 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10705 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571E
, 0, 0, 0 },
10706 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10707 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571F
, 0, 0,
10708 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10709 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10710 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572F
, 0, 0,
10711 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10712 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10713 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B5
, 0, 0, 0 },
10714 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10715 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_574D
, 0, 0, 0 },
10716 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10717 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B2
, 0, 0, 0 },
10718 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10719 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C0
, 0, 0, 0 },
10720 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10721 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C3
, 0, 0, 0 },
10722 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10723 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C4
, 0, 0, 0 },
10724 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10725 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B4
, 0, 0, 0 },
10726 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10727 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B1
, 0, 0, 0 },
10728 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10729 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C6
, 0, 0, 0 },
10730 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10731 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C8
, 0, 0, 0 },
10732 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10733 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57CE
, 0, 0, 0 },
10734 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10735 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D5
, 0, 0, 0 },
10736 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10737 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D6
, 0, 0, 0 },
10738 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10739 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D7
, 0, 0, 0 },
10740 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10741 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D8
, 0, 0, 0 },
10742 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10743 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D9
, 0, 0, 0 },
10744 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10745 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57DA
, 0, 0, 0 },
10746 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10747 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EB
, 0, 0, 0 },
10748 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10749 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EC
, 0, 0, 0 },
10750 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10751 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57ED
, 0, 0, 0 },
10752 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10753 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EE
, 0, 0, 0 },
10754 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10755 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EF
, 0, 0, 0 },
10756 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10757 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57F0
, 0, 0, 0 },
10758 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10759 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CCA
, 0, 0, 0 },
10760 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10761 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CD2
, 0, 0, 0 },
10762 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10763 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CCD
, 0, 0, 0 },
10764 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_RATTLESNAKE
,
10765 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_580A
, 0, 0, 0 },
10766 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_RATTLESNAKE
,
10767 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_580B
, 0, 0, 0 },
10770 MODULE_DEVICE_TABLE(pci
, ipr_pci_table
);
10772 static const struct pci_error_handlers ipr_err_handler
= {
10773 .error_detected
= ipr_pci_error_detected
,
10774 .mmio_enabled
= ipr_pci_mmio_enabled
,
10775 .slot_reset
= ipr_pci_slot_reset
,
10778 static struct pci_driver ipr_driver
= {
10780 .id_table
= ipr_pci_table
,
10781 .probe
= ipr_probe
,
10782 .remove
= ipr_remove
,
10783 .shutdown
= ipr_shutdown
,
10784 .err_handler
= &ipr_err_handler
,
10788 * ipr_halt_done - Shutdown prepare completion
10793 static void ipr_halt_done(struct ipr_cmnd
*ipr_cmd
)
10795 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
10799 * ipr_halt - Issue shutdown prepare to all adapters
10802 * NOTIFY_OK on success / NOTIFY_DONE on failure
10804 static int ipr_halt(struct notifier_block
*nb
, ulong event
, void *buf
)
10806 struct ipr_cmnd
*ipr_cmd
;
10807 struct ipr_ioa_cfg
*ioa_cfg
;
10808 unsigned long flags
= 0, driver_lock_flags
;
10810 if (event
!= SYS_RESTART
&& event
!= SYS_HALT
&& event
!= SYS_POWER_OFF
)
10811 return NOTIFY_DONE
;
10813 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10815 list_for_each_entry(ioa_cfg
, &ipr_ioa_head
, queue
) {
10816 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
10817 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
||
10818 (ipr_fast_reboot
&& event
== SYS_RESTART
&& ioa_cfg
->sis64
)) {
10819 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
10823 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
10824 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
10825 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
10826 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = IPR_IOA_SHUTDOWN
;
10827 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL
;
10829 ipr_do_req(ipr_cmd
, ipr_halt_done
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
10830 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
10832 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10837 static struct notifier_block ipr_notifier
= {
10842 * ipr_init - Module entry point
10845 * 0 on success / negative value on failure
10847 static int __init
ipr_init(void)
10849 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10850 IPR_DRIVER_VERSION
, IPR_DRIVER_DATE
);
10852 register_reboot_notifier(&ipr_notifier
);
10853 return pci_register_driver(&ipr_driver
);
10857 * ipr_exit - Module unload
10859 * Module unload entry point.
10864 static void __exit
ipr_exit(void)
10866 unregister_reboot_notifier(&ipr_notifier
);
10867 pci_unregister_driver(&ipr_driver
);
10870 module_init(ipr_init
);
10871 module_exit(ipr_exit
);