2 * ipr.c -- driver for IBM Power Linux RAID adapters
4 * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
6 * Copyright (C) 2003, 2004 IBM Corporation
8 * This program is free software; you can redistribute it and/or modify
9 * it under the terms of the GNU General Public License as published by
10 * the Free Software Foundation; either version 2 of the License, or
11 * (at your option) any later version.
13 * This program is distributed in the hope that it will be useful,
14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
16 * GNU General Public License for more details.
18 * You should have received a copy of the GNU General Public License
19 * along with this program; if not, write to the Free Software
20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
27 * This driver is used to control the following SCSI adapters:
29 * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
31 * IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
32 * PCI-X Dual Channel Ultra 320 SCSI Adapter
33 * PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
34 * Embedded SCSI adapter on p615 and p655 systems
36 * Supported Hardware Features:
37 * - Ultra 320 SCSI controller
38 * - PCI-X host interface
39 * - Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
40 * - Non-Volatile Write Cache
41 * - Supports attachment of non-RAID disks, tape, and optical devices
42 * - RAID Levels 0, 5, 10
44 * - Background Parity Checking
45 * - Background Data Scrubbing
46 * - Ability to increase the capacity of an existing RAID 5 disk array
50 * - Tagged command queuing
51 * - Adapter microcode download
53 * - SCSI device hot plug
58 #include <linux/init.h>
59 #include <linux/types.h>
60 #include <linux/errno.h>
61 #include <linux/kernel.h>
62 #include <linux/slab.h>
63 #include <linux/vmalloc.h>
64 #include <linux/ioport.h>
65 #include <linux/delay.h>
66 #include <linux/pci.h>
67 #include <linux/wait.h>
68 #include <linux/spinlock.h>
69 #include <linux/sched.h>
70 #include <linux/interrupt.h>
71 #include <linux/blkdev.h>
72 #include <linux/firmware.h>
73 #include <linux/module.h>
74 #include <linux/moduleparam.h>
75 #include <linux/libata.h>
76 #include <linux/hdreg.h>
77 #include <linux/reboot.h>
78 #include <linux/stringify.h>
81 #include <asm/processor.h>
82 #include <scsi/scsi.h>
83 #include <scsi/scsi_host.h>
84 #include <scsi/scsi_tcq.h>
85 #include <scsi/scsi_eh.h>
86 #include <scsi/scsi_cmnd.h>
92 static LIST_HEAD(ipr_ioa_head);
93 static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
94 static unsigned int ipr_max_speed = 1;
95 static int ipr_testmode = 0;
96 static unsigned int ipr_fastfail = 0;
97 static unsigned int ipr_transop_timeout = 0;
98 static unsigned int ipr_debug = 0;
99 static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
100 static unsigned int ipr_dual_ioa_raid = 1;
101 static unsigned int ipr_number_of_msix = 16;
102 static unsigned int ipr_fast_reboot;
103 static DEFINE_SPINLOCK(ipr_driver_lock);
105 /* This table describes the differences between DMA controller chips */
106 static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
107 { /* Gemstone, Citrine, Obsidian, and Obsidian-E */
110 .cache_line_size = 0x20,
114 .set_interrupt_mask_reg = 0x0022C,
115 .clr_interrupt_mask_reg = 0x00230,
116 .clr_interrupt_mask_reg32 = 0x00230,
117 .sense_interrupt_mask_reg = 0x0022C,
118 .sense_interrupt_mask_reg32 = 0x0022C,
119 .clr_interrupt_reg = 0x00228,
120 .clr_interrupt_reg32 = 0x00228,
121 .sense_interrupt_reg = 0x00224,
122 .sense_interrupt_reg32 = 0x00224,
123 .ioarrin_reg = 0x00404,
124 .sense_uproc_interrupt_reg = 0x00214,
125 .sense_uproc_interrupt_reg32 = 0x00214,
126 .set_uproc_interrupt_reg = 0x00214,
127 .set_uproc_interrupt_reg32 = 0x00214,
128 .clr_uproc_interrupt_reg = 0x00218,
129 .clr_uproc_interrupt_reg32 = 0x00218
132 { /* Snipe and Scamp */
135 .cache_line_size = 0x20,
139 .set_interrupt_mask_reg = 0x00288,
140 .clr_interrupt_mask_reg = 0x0028C,
141 .clr_interrupt_mask_reg32 = 0x0028C,
142 .sense_interrupt_mask_reg = 0x00288,
143 .sense_interrupt_mask_reg32 = 0x00288,
144 .clr_interrupt_reg = 0x00284,
145 .clr_interrupt_reg32 = 0x00284,
146 .sense_interrupt_reg = 0x00280,
147 .sense_interrupt_reg32 = 0x00280,
148 .ioarrin_reg = 0x00504,
149 .sense_uproc_interrupt_reg = 0x00290,
150 .sense_uproc_interrupt_reg32 = 0x00290,
151 .set_uproc_interrupt_reg = 0x00290,
152 .set_uproc_interrupt_reg32 = 0x00290,
153 .clr_uproc_interrupt_reg = 0x00294,
154 .clr_uproc_interrupt_reg32 = 0x00294
160 .cache_line_size = 0x20,
164 .set_interrupt_mask_reg = 0x00010,
165 .clr_interrupt_mask_reg = 0x00018,
166 .clr_interrupt_mask_reg32 = 0x0001C,
167 .sense_interrupt_mask_reg = 0x00010,
168 .sense_interrupt_mask_reg32 = 0x00014,
169 .clr_interrupt_reg = 0x00008,
170 .clr_interrupt_reg32 = 0x0000C,
171 .sense_interrupt_reg = 0x00000,
172 .sense_interrupt_reg32 = 0x00004,
173 .ioarrin_reg = 0x00070,
174 .sense_uproc_interrupt_reg = 0x00020,
175 .sense_uproc_interrupt_reg32 = 0x00024,
176 .set_uproc_interrupt_reg = 0x00020,
177 .set_uproc_interrupt_reg32 = 0x00024,
178 .clr_uproc_interrupt_reg = 0x00028,
179 .clr_uproc_interrupt_reg32 = 0x0002C,
180 .init_feedback_reg = 0x0005C,
181 .dump_addr_reg = 0x00064,
182 .dump_data_reg = 0x00068,
183 .endian_swap_reg = 0x00084
188 static const struct ipr_chip_t ipr_chip[] = {
189 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
190 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
191 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
192 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
193 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, true, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
194 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
195 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
196 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
197 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
198 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
201 static int ipr_max_bus_speeds[] = {
202 IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
205 MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
206 MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
207 module_param_named(max_speed, ipr_max_speed, uint, 0);
208 MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
209 module_param_named(log_level, ipr_log_level, uint, 0);
210 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
211 module_param_named(testmode, ipr_testmode, int, 0);
212 MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
213 module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
214 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
215 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
216 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
217 module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
218 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
219 module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
220 MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
221 module_param_named(max_devs, ipr_max_devs, int, 0);
222 MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
223 "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
224 module_param_named(number_of_msix, ipr_number_of_msix, int, 0);
225 MODULE_PARM_DESC(number_of_msix, "Specify the number of MSIX interrupts to use on capable adapters (1 - 16). (default:16)");
226 module_param_named(fast_reboot, ipr_fast_reboot, int, S_IRUGO | S_IWUSR);
227 MODULE_PARM_DESC(fast_reboot, "Skip adapter shutdown during reboot. Set to 1 to enable. (default: 0)");
228 MODULE_LICENSE("GPL");
229 MODULE_VERSION(IPR_DRIVER_VERSION);
231 /* A constant array of IOASCs/URCs/Error Messages */
233 struct ipr_error_table_t ipr_error_table[] = {
234 {0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
235 "8155: An unknown error was received"},
237 "Soft underlength error"},
239 "Command to be cancelled not found"},
241 "Qualified success"},
242 {0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
243 "FFFE: Soft device bus error recovered by the IOA"},
244 {0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
245 "4101: Soft device bus fabric error"},
246 {0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
247 "FFFC: Logical block guard error recovered by the device"},
248 {0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
249 "FFFC: Logical block reference tag error recovered by the device"},
250 {0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
251 "4171: Recovered scatter list tag / sequence number error"},
252 {0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
253 "FF3D: Recovered logical block CRC error on IOA to Host transfer"},
254 {0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
255 "4171: Recovered logical block sequence number error on IOA to Host transfer"},
256 {0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
257 "FFFD: Recovered logical block reference tag error detected by the IOA"},
258 {0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
259 "FFFD: Logical block guard error recovered by the IOA"},
260 {0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
261 "FFF9: Device sector reassign successful"},
262 {0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
263 "FFF7: Media error recovered by device rewrite procedures"},
264 {0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
265 "7001: IOA sector reassignment successful"},
266 {0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
267 "FFF9: Soft media error. Sector reassignment recommended"},
268 {0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
269 "FFF7: Media error recovered by IOA rewrite procedures"},
270 {0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
271 "FF3D: Soft PCI bus error recovered by the IOA"},
272 {0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
273 "FFF6: Device hardware error recovered by the IOA"},
274 {0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
275 "FFF6: Device hardware error recovered by the device"},
276 {0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
277 "FF3D: Soft IOA error recovered by the IOA"},
278 {0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
279 "FFFA: Undefined device response recovered by the IOA"},
280 {0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
281 "FFF6: Device bus error, message or command phase"},
282 {0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
283 "FFFE: Task Management Function failed"},
284 {0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
285 "FFF6: Failure prediction threshold exceeded"},
286 {0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
287 "8009: Impending cache battery pack failure"},
289 "Logical Unit in process of becoming ready"},
291 "Initializing command required"},
293 "34FF: Disk device format in progress"},
295 "Logical unit not accessible, target port in unavailable state"},
296 {0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
297 "9070: IOA requested reset"},
299 "Synchronization required"},
301 "IOA microcode download required"},
303 "Device bus connection is prohibited by host"},
305 "No ready, IOA shutdown"},
307 "Not ready, IOA has been shutdown"},
308 {0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
309 "3020: Storage subsystem configuration error"},
311 "FFF5: Medium error, data unreadable, recommend reassign"},
313 "7000: Medium error, data unreadable, do not reassign"},
314 {0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
315 "FFF3: Disk media format bad"},
316 {0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
317 "3002: Addressed device failed to respond to selection"},
318 {0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
319 "3100: Device bus error"},
320 {0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
321 "3109: IOA timed out a device command"},
323 "3120: SCSI bus is not operational"},
324 {0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
325 "4100: Hard device bus fabric error"},
326 {0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
327 "310C: Logical block guard error detected by the device"},
328 {0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
329 "310C: Logical block reference tag error detected by the device"},
330 {0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
331 "4170: Scatter list tag / sequence number error"},
332 {0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
333 "8150: Logical block CRC error on IOA to Host transfer"},
334 {0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
335 "4170: Logical block sequence number error on IOA to Host transfer"},
336 {0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
337 "310D: Logical block reference tag error detected by the IOA"},
338 {0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
339 "310D: Logical block guard error detected by the IOA"},
340 {0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
341 "9000: IOA reserved area data check"},
342 {0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
343 "9001: IOA reserved area invalid data pattern"},
344 {0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
345 "9002: IOA reserved area LRC error"},
346 {0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
347 "Hardware Error, IOA metadata access error"},
348 {0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
349 "102E: Out of alternate sectors for disk storage"},
350 {0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
351 "FFF4: Data transfer underlength error"},
352 {0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
353 "FFF4: Data transfer overlength error"},
354 {0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
355 "3400: Logical unit failure"},
356 {0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
357 "FFF4: Device microcode is corrupt"},
358 {0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
359 "8150: PCI bus error"},
361 "Unsupported device bus message received"},
362 {0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
363 "FFF4: Disk device problem"},
364 {0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
365 "8150: Permanent IOA failure"},
366 {0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
367 "3010: Disk device returned wrong response to IOA"},
368 {0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
369 "8151: IOA microcode error"},
371 "Device bus status error"},
372 {0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
373 "8157: IOA error requiring IOA reset to recover"},
375 "ATA device status error"},
377 "Message reject received from the device"},
378 {0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
379 "8008: A permanent cache battery pack failure occurred"},
380 {0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
381 "9090: Disk unit has been modified after the last known status"},
382 {0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
383 "9081: IOA detected device error"},
384 {0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
385 "9082: IOA detected device error"},
386 {0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
387 "3110: Device bus error, message or command phase"},
388 {0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
389 "3110: SAS Command / Task Management Function failed"},
390 {0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
391 "9091: Incorrect hardware configuration change has been detected"},
392 {0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
393 "9073: Invalid multi-adapter configuration"},
394 {0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
395 "4010: Incorrect connection between cascaded expanders"},
396 {0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
397 "4020: Connections exceed IOA design limits"},
398 {0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
399 "4030: Incorrect multipath connection"},
400 {0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
401 "4110: Unsupported enclosure function"},
402 {0x04679800, 0, IPR_DEFAULT_LOG_LEVEL,
403 "4120: SAS cable VPD cannot be read"},
404 {0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
405 "FFF4: Command to logical unit failed"},
407 "Illegal request, invalid request type or request packet"},
409 "Illegal request, invalid resource handle"},
411 "Illegal request, commands not allowed to this device"},
413 "Illegal request, command not allowed to a secondary adapter"},
415 "Illegal request, command not allowed to a non-optimized resource"},
417 "Illegal request, invalid field in parameter list"},
419 "Illegal request, parameter not supported"},
421 "Illegal request, parameter value invalid"},
423 "Illegal request, command sequence error"},
425 "Illegal request, dual adapter support not enabled"},
427 "Illegal request, another cable connector was physically disabled"},
429 "Illegal request, inconsistent group id/group count"},
430 {0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
431 "9031: Array protection temporarily suspended, protection resuming"},
432 {0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
433 "9040: Array protection temporarily suspended, protection resuming"},
434 {0x060B0100, 0, IPR_DEFAULT_LOG_LEVEL,
435 "4080: IOA exceeded maximum operating temperature"},
436 {0x060B8000, 0, IPR_DEFAULT_LOG_LEVEL,
437 "4085: Service required"},
438 {0x060B8100, 0, IPR_DEFAULT_LOG_LEVEL,
439 "4086: SAS Adapter Hardware Configuration Error"},
440 {0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
441 "3140: Device bus not ready to ready transition"},
442 {0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
443 "FFFB: SCSI bus was reset"},
445 "FFFE: SCSI bus transition to single ended"},
447 "FFFE: SCSI bus transition to LVD"},
448 {0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
449 "FFFB: SCSI bus was reset by another initiator"},
450 {0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
451 "3029: A device replacement has occurred"},
452 {0x063F8300, 0, IPR_DEFAULT_LOG_LEVEL,
453 "4102: Device bus fabric performance degradation"},
454 {0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
455 "9051: IOA cache data exists for a missing or failed device"},
456 {0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
457 "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
458 {0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
459 "9025: Disk unit is not supported at its physical location"},
460 {0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
461 "3020: IOA detected a SCSI bus configuration error"},
462 {0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
463 "3150: SCSI bus configuration error"},
464 {0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
465 "9074: Asymmetric advanced function disk configuration"},
466 {0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
467 "4040: Incomplete multipath connection between IOA and enclosure"},
468 {0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
469 "4041: Incomplete multipath connection between enclosure and device"},
470 {0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
471 "9075: Incomplete multipath connection between IOA and remote IOA"},
472 {0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
473 "9076: Configuration error, missing remote IOA"},
474 {0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
475 "4050: Enclosure does not support a required multipath function"},
476 {0x06679800, 0, IPR_DEFAULT_LOG_LEVEL,
477 "4121: Configuration error, required cable is missing"},
478 {0x06679900, 0, IPR_DEFAULT_LOG_LEVEL,
479 "4122: Cable is not plugged into the correct location on remote IOA"},
480 {0x06679A00, 0, IPR_DEFAULT_LOG_LEVEL,
481 "4123: Configuration error, invalid cable vital product data"},
482 {0x06679B00, 0, IPR_DEFAULT_LOG_LEVEL,
483 "4124: Configuration error, both cable ends are plugged into the same IOA"},
484 {0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
485 "4070: Logically bad block written on device"},
486 {0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
487 "9041: Array protection temporarily suspended"},
488 {0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
489 "9042: Corrupt array parity detected on specified device"},
490 {0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
491 "9030: Array no longer protected due to missing or failed disk unit"},
492 {0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
493 "9071: Link operational transition"},
494 {0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
495 "9072: Link not operational transition"},
496 {0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
497 "9032: Array exposed but still protected"},
498 {0x066B8300, 0, IPR_DEBUG_LOG_LEVEL,
499 "70DD: Device forced failed by disrupt device command"},
500 {0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
501 "4061: Multipath redundancy level got better"},
502 {0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
503 "4060: Multipath redundancy level got worse"},
504 {0x06808100, 0, IPR_DEBUG_LOG_LEVEL,
505 "9083: Device raw mode enabled"},
506 {0x06808200, 0, IPR_DEBUG_LOG_LEVEL,
507 "9084: Device raw mode disabled"},
509 "Failure due to other device"},
510 {0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
511 "9008: IOA does not support functions expected by devices"},
512 {0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
513 "9010: Cache data associated with attached devices cannot be found"},
514 {0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
515 "9011: Cache data belongs to devices other than those attached"},
516 {0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
517 "9020: Array missing 2 or more devices with only 1 device present"},
518 {0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
519 "9021: Array missing 2 or more devices with 2 or more devices present"},
520 {0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
521 "9022: Exposed array is missing a required device"},
522 {0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
523 "9023: Array member(s) not at required physical locations"},
524 {0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
525 "9024: Array not functional due to present hardware configuration"},
526 {0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
527 "9026: Array not functional due to present hardware configuration"},
528 {0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
529 "9027: Array is missing a device and parity is out of sync"},
530 {0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
531 "9028: Maximum number of arrays already exist"},
532 {0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
533 "9050: Required cache data cannot be located for a disk unit"},
534 {0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
535 "9052: Cache data exists for a device that has been modified"},
536 {0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
537 "9054: IOA resources not available due to previous problems"},
538 {0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
539 "9092: Disk unit requires initialization before use"},
540 {0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
541 "9029: Incorrect hardware configuration change has been detected"},
542 {0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
543 "9060: One or more disk pairs are missing from an array"},
544 {0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
545 "9061: One or more disks are missing from an array"},
546 {0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
547 "9062: One or more disks are missing from an array"},
548 {0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
549 "9063: Maximum number of functional arrays has been exceeded"},
551 "Data protect, other volume set problem"},
553 "Aborted command, invalid descriptor"},
555 "Target operating conditions have changed, dual adapter takeover"},
557 "Aborted command, medium removal prevented"},
559 "Command terminated by host"},
561 "Aborted command, command terminated by host"}
564 static const struct ipr_ses_table_entry ipr_ses_table[] = {
565 { "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
566 { "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
567 { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
568 { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
569 { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
570 { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
571 { "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
572 { "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
573 { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
574 { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
575 { "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
576 { "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
577 { "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
581 * Function Prototypes
583 static int ipr_reset_alert(struct ipr_cmnd *);
584 static void ipr_process_ccn(struct ipr_cmnd *);
585 static void ipr_process_error(struct ipr_cmnd *);
586 static void ipr_reset_ioa_job(struct ipr_cmnd *);
587 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
588 enum ipr_shutdown_type);
590 #ifdef CONFIG_SCSI_IPR_TRACE
592 * ipr_trc_hook - Add a trace entry to the driver trace
593 * @ipr_cmd: ipr command struct
595 * @add_data: additional data
600 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
601 u8 type, u32 add_data)
603 struct ipr_trace_entry *trace_entry;
604 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
605 unsigned int trace_index;
607 trace_index = atomic_add_return(1, &ioa_cfg->trace_index) & IPR_TRACE_INDEX_MASK;
608 trace_entry = &ioa_cfg->trace[trace_index];
609 trace_entry->time = jiffies;
610 trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
611 trace_entry->type = type;
612 if (ipr_cmd->ioa_cfg->sis64)
613 trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
615 trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
616 trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
617 trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
618 trace_entry->u.add_data = add_data;
622 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
626 * ipr_lock_and_done - Acquire lock and complete command
627 * @ipr_cmd: ipr command struct
632 static void ipr_lock_and_done(struct ipr_cmnd *ipr_cmd)
634 unsigned long lock_flags;
635 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
637 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
638 ipr_cmd->done(ipr_cmd);
639 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
643 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
644 * @ipr_cmd: ipr command struct
649 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
651 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
652 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
653 struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
654 dma_addr_t dma_addr = ipr_cmd->dma_addr;
657 hrrq_id = ioarcb->cmd_pkt.hrrq_id;
658 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
659 ioarcb->cmd_pkt.hrrq_id = hrrq_id;
660 ioarcb->data_transfer_length = 0;
661 ioarcb->read_data_transfer_length = 0;
662 ioarcb->ioadl_len = 0;
663 ioarcb->read_ioadl_len = 0;
665 if (ipr_cmd->ioa_cfg->sis64) {
666 ioarcb->u.sis64_addr_data.data_ioadl_addr =
667 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
668 ioasa64->u.gata.status = 0;
670 ioarcb->write_ioadl_addr =
671 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
672 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
673 ioasa->u.gata.status = 0;
676 ioasa->hdr.ioasc = 0;
677 ioasa->hdr.residual_data_len = 0;
678 ipr_cmd->scsi_cmd = NULL;
680 ipr_cmd->sense_buffer[0] = 0;
681 ipr_cmd->dma_use_sg = 0;
685 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
686 * @ipr_cmd: ipr command struct
691 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd,
692 void (*fast_done) (struct ipr_cmnd *))
694 ipr_reinit_ipr_cmnd(ipr_cmd);
695 ipr_cmd->u.scratch = 0;
696 ipr_cmd->sibling = NULL;
697 ipr_cmd->eh_comp = NULL;
698 ipr_cmd->fast_done = fast_done;
699 timer_setup(&ipr_cmd->timer, NULL, 0);
703 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
704 * @ioa_cfg: ioa config struct
707 * pointer to ipr command struct
710 struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq)
712 struct ipr_cmnd *ipr_cmd = NULL;
714 if (likely(!list_empty(&hrrq->hrrq_free_q))) {
715 ipr_cmd = list_entry(hrrq->hrrq_free_q.next,
716 struct ipr_cmnd, queue);
717 list_del(&ipr_cmd->queue);
725 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
726 * @ioa_cfg: ioa config struct
729 * pointer to ipr command struct
732 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
734 struct ipr_cmnd *ipr_cmd =
735 __ipr_get_free_ipr_cmnd(&ioa_cfg->hrrq[IPR_INIT_HRRQ]);
736 ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
741 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
742 * @ioa_cfg: ioa config struct
743 * @clr_ints: interrupts to clear
745 * This function masks all interrupts on the adapter, then clears the
746 * interrupts specified in the mask
751 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
754 volatile u32 int_reg;
757 /* Stop new interrupts */
758 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
759 spin_lock(&ioa_cfg->hrrq[i]._lock);
760 ioa_cfg->hrrq[i].allow_interrupts = 0;
761 spin_unlock(&ioa_cfg->hrrq[i]._lock);
765 /* Set interrupt mask to stop all new interrupts */
767 writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
769 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
771 /* Clear any pending interrupts */
773 writel(~0, ioa_cfg->regs.clr_interrupt_reg);
774 writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
775 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
779 * ipr_save_pcix_cmd_reg - Save PCI-X command register
780 * @ioa_cfg: ioa config struct
783 * 0 on success / -EIO on failure
785 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
787 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
789 if (pcix_cmd_reg == 0)
792 if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
793 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
794 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
798 ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
803 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
804 * @ioa_cfg: ioa config struct
807 * 0 on success / -EIO on failure
809 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
811 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
814 if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
815 ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
816 dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
825 * __ipr_sata_eh_done - done function for aborted SATA commands
826 * @ipr_cmd: ipr command struct
828 * This function is invoked for ops generated to SATA
829 * devices which are being aborted.
834 static void __ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
836 struct ata_queued_cmd *qc = ipr_cmd->qc;
837 struct ipr_sata_port *sata_port = qc->ap->private_data;
839 qc->err_mask |= AC_ERR_OTHER;
840 sata_port->ioasa.status |= ATA_BUSY;
842 if (ipr_cmd->eh_comp)
843 complete(ipr_cmd->eh_comp);
844 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
848 * ipr_sata_eh_done - done function for aborted SATA commands
849 * @ipr_cmd: ipr command struct
851 * This function is invoked for ops generated to SATA
852 * devices which are being aborted.
857 static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
859 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
860 unsigned long hrrq_flags;
862 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
863 __ipr_sata_eh_done(ipr_cmd);
864 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
868 * __ipr_scsi_eh_done - mid-layer done function for aborted ops
869 * @ipr_cmd: ipr command struct
871 * This function is invoked by the interrupt handler for
872 * ops generated by the SCSI mid-layer which are being aborted.
877 static void __ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
879 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
881 scsi_cmd->result |= (DID_ERROR << 16);
883 scsi_dma_unmap(ipr_cmd->scsi_cmd);
884 scsi_cmd->scsi_done(scsi_cmd);
885 if (ipr_cmd->eh_comp)
886 complete(ipr_cmd->eh_comp);
887 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
891 * ipr_scsi_eh_done - mid-layer done function for aborted ops
892 * @ipr_cmd: ipr command struct
894 * This function is invoked by the interrupt handler for
895 * ops generated by the SCSI mid-layer which are being aborted.
900 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
902 unsigned long hrrq_flags;
903 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
905 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
906 __ipr_scsi_eh_done(ipr_cmd);
907 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
911 * ipr_fail_all_ops - Fails all outstanding ops.
912 * @ioa_cfg: ioa config struct
914 * This function fails all outstanding ops.
919 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
921 struct ipr_cmnd *ipr_cmd, *temp;
922 struct ipr_hrr_queue *hrrq;
925 for_each_hrrq(hrrq, ioa_cfg) {
926 spin_lock(&hrrq->_lock);
927 list_for_each_entry_safe(ipr_cmd,
928 temp, &hrrq->hrrq_pending_q, queue) {
929 list_del(&ipr_cmd->queue);
931 ipr_cmd->s.ioasa.hdr.ioasc =
932 cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
933 ipr_cmd->s.ioasa.hdr.ilid =
934 cpu_to_be32(IPR_DRIVER_ILID);
936 if (ipr_cmd->scsi_cmd)
937 ipr_cmd->done = __ipr_scsi_eh_done;
938 else if (ipr_cmd->qc)
939 ipr_cmd->done = __ipr_sata_eh_done;
941 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH,
942 IPR_IOASC_IOA_WAS_RESET);
943 del_timer(&ipr_cmd->timer);
944 ipr_cmd->done(ipr_cmd);
946 spin_unlock(&hrrq->_lock);
952 * ipr_send_command - Send driver initiated requests.
953 * @ipr_cmd: ipr command struct
955 * This function sends a command to the adapter using the correct write call.
956 * In the case of sis64, calculate the ioarcb size required. Then or in the
962 static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
964 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
965 dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
967 if (ioa_cfg->sis64) {
968 /* The default size is 256 bytes */
969 send_dma_addr |= 0x1;
971 /* If the number of ioadls * size of ioadl > 128 bytes,
972 then use a 512 byte ioarcb */
973 if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
974 send_dma_addr |= 0x4;
975 writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
977 writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
981 * ipr_do_req - Send driver initiated requests.
982 * @ipr_cmd: ipr command struct
983 * @done: done function
984 * @timeout_func: timeout function
985 * @timeout: timeout value
987 * This function sends the specified command to the adapter with the
988 * timeout given. The done function is invoked on command completion.
993 static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
994 void (*done) (struct ipr_cmnd *),
995 void (*timeout_func) (struct timer_list *), u32 timeout)
997 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
999 ipr_cmd->done = done;
1001 ipr_cmd->timer.expires = jiffies + timeout;
1002 ipr_cmd->timer.function = timeout_func;
1004 add_timer(&ipr_cmd->timer);
1006 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
1008 ipr_send_command(ipr_cmd);
1012 * ipr_internal_cmd_done - Op done function for an internally generated op.
1013 * @ipr_cmd: ipr command struct
1015 * This function is the op done function for an internally generated,
1016 * blocking op. It simply wakes the sleeping thread.
1021 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
1023 if (ipr_cmd->sibling)
1024 ipr_cmd->sibling = NULL;
1026 complete(&ipr_cmd->completion);
1030 * ipr_init_ioadl - initialize the ioadl for the correct SIS type
1031 * @ipr_cmd: ipr command struct
1032 * @dma_addr: dma address
1033 * @len: transfer length
1034 * @flags: ioadl flag value
1036 * This function initializes an ioadl in the case where there is only a single
1042 static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
1045 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
1046 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
1048 ipr_cmd->dma_use_sg = 1;
1050 if (ipr_cmd->ioa_cfg->sis64) {
1051 ioadl64->flags = cpu_to_be32(flags);
1052 ioadl64->data_len = cpu_to_be32(len);
1053 ioadl64->address = cpu_to_be64(dma_addr);
1055 ipr_cmd->ioarcb.ioadl_len =
1056 cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
1057 ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
1059 ioadl->flags_and_data_len = cpu_to_be32(flags | len);
1060 ioadl->address = cpu_to_be32(dma_addr);
1062 if (flags == IPR_IOADL_FLAGS_READ_LAST) {
1063 ipr_cmd->ioarcb.read_ioadl_len =
1064 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
1065 ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
1067 ipr_cmd->ioarcb.ioadl_len =
1068 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
1069 ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
1075 * ipr_send_blocking_cmd - Send command and sleep on its completion.
1076 * @ipr_cmd: ipr command struct
1077 * @timeout_func: function to invoke if command times out
1083 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
1084 void (*timeout_func) (struct timer_list *),
1087 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1089 init_completion(&ipr_cmd->completion);
1090 ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
1092 spin_unlock_irq(ioa_cfg->host->host_lock);
1093 wait_for_completion(&ipr_cmd->completion);
1094 spin_lock_irq(ioa_cfg->host->host_lock);
1097 static int ipr_get_hrrq_index(struct ipr_ioa_cfg *ioa_cfg)
1101 if (ioa_cfg->hrrq_num == 1)
1104 hrrq = atomic_add_return(1, &ioa_cfg->hrrq_index);
1105 hrrq = (hrrq % (ioa_cfg->hrrq_num - 1)) + 1;
1111 * ipr_send_hcam - Send an HCAM to the adapter.
1112 * @ioa_cfg: ioa config struct
1114 * @hostrcb: hostrcb struct
1116 * This function will send a Host Controlled Async command to the adapter.
1117 * If HCAMs are currently not allowed to be issued to the adapter, it will
1118 * place the hostrcb on the free queue.
1123 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
1124 struct ipr_hostrcb *hostrcb)
1126 struct ipr_cmnd *ipr_cmd;
1127 struct ipr_ioarcb *ioarcb;
1129 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
1130 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
1131 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
1132 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
1134 ipr_cmd->u.hostrcb = hostrcb;
1135 ioarcb = &ipr_cmd->ioarcb;
1137 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
1138 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
1139 ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
1140 ioarcb->cmd_pkt.cdb[1] = type;
1141 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
1142 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
1144 ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
1145 sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
1147 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
1148 ipr_cmd->done = ipr_process_ccn;
1150 ipr_cmd->done = ipr_process_error;
1152 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
1154 ipr_send_command(ipr_cmd);
1156 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
1161 * ipr_update_ata_class - Update the ata class in the resource entry
1162 * @res: resource entry struct
1163 * @proto: cfgte device bus protocol value
1168 static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1171 case IPR_PROTO_SATA:
1172 case IPR_PROTO_SAS_STP:
1173 res->ata_class = ATA_DEV_ATA;
1175 case IPR_PROTO_SATA_ATAPI:
1176 case IPR_PROTO_SAS_STP_ATAPI:
1177 res->ata_class = ATA_DEV_ATAPI;
1180 res->ata_class = ATA_DEV_UNKNOWN;
1186 * ipr_init_res_entry - Initialize a resource entry struct.
1187 * @res: resource entry struct
1188 * @cfgtew: config table entry wrapper struct
1193 static void ipr_init_res_entry(struct ipr_resource_entry *res,
1194 struct ipr_config_table_entry_wrapper *cfgtew)
1198 struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1199 struct ipr_resource_entry *gscsi_res = NULL;
1201 res->needs_sync_complete = 0;
1204 res->del_from_ml = 0;
1205 res->resetting_device = 0;
1206 res->reset_occurred = 0;
1208 res->sata_port = NULL;
1210 if (ioa_cfg->sis64) {
1211 proto = cfgtew->u.cfgte64->proto;
1212 res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
1213 res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
1214 res->qmodel = IPR_QUEUEING_MODEL64(res);
1215 res->type = cfgtew->u.cfgte64->res_type;
1217 memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1218 sizeof(res->res_path));
1221 memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1222 sizeof(res->dev_lun.scsi_lun));
1223 res->lun = scsilun_to_int(&res->dev_lun);
1225 if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1226 list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
1227 if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
1229 res->target = gscsi_res->target;
1234 res->target = find_first_zero_bit(ioa_cfg->target_ids,
1235 ioa_cfg->max_devs_supported);
1236 set_bit(res->target, ioa_cfg->target_ids);
1238 } else if (res->type == IPR_RES_TYPE_IOAFP) {
1239 res->bus = IPR_IOAFP_VIRTUAL_BUS;
1241 } else if (res->type == IPR_RES_TYPE_ARRAY) {
1242 res->bus = IPR_ARRAY_VIRTUAL_BUS;
1243 res->target = find_first_zero_bit(ioa_cfg->array_ids,
1244 ioa_cfg->max_devs_supported);
1245 set_bit(res->target, ioa_cfg->array_ids);
1246 } else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
1247 res->bus = IPR_VSET_VIRTUAL_BUS;
1248 res->target = find_first_zero_bit(ioa_cfg->vset_ids,
1249 ioa_cfg->max_devs_supported);
1250 set_bit(res->target, ioa_cfg->vset_ids);
1252 res->target = find_first_zero_bit(ioa_cfg->target_ids,
1253 ioa_cfg->max_devs_supported);
1254 set_bit(res->target, ioa_cfg->target_ids);
1257 proto = cfgtew->u.cfgte->proto;
1258 res->qmodel = IPR_QUEUEING_MODEL(res);
1259 res->flags = cfgtew->u.cfgte->flags;
1260 if (res->flags & IPR_IS_IOA_RESOURCE)
1261 res->type = IPR_RES_TYPE_IOAFP;
1263 res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1265 res->bus = cfgtew->u.cfgte->res_addr.bus;
1266 res->target = cfgtew->u.cfgte->res_addr.target;
1267 res->lun = cfgtew->u.cfgte->res_addr.lun;
1268 res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
1271 ipr_update_ata_class(res, proto);
1275 * ipr_is_same_device - Determine if two devices are the same.
1276 * @res: resource entry struct
1277 * @cfgtew: config table entry wrapper struct
1280 * 1 if the devices are the same / 0 otherwise
1282 static int ipr_is_same_device(struct ipr_resource_entry *res,
1283 struct ipr_config_table_entry_wrapper *cfgtew)
1285 if (res->ioa_cfg->sis64) {
1286 if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
1287 sizeof(cfgtew->u.cfgte64->dev_id)) &&
1288 !memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1289 sizeof(cfgtew->u.cfgte64->lun))) {
1293 if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
1294 res->target == cfgtew->u.cfgte->res_addr.target &&
1295 res->lun == cfgtew->u.cfgte->res_addr.lun)
1303 * __ipr_format_res_path - Format the resource path for printing.
1304 * @res_path: resource path
1306 * @len: length of buffer provided
1311 static char *__ipr_format_res_path(u8 *res_path, char *buffer, int len)
1317 p += snprintf(p, buffer + len - p, "%02X", res_path[0]);
1318 for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++)
1319 p += snprintf(p, buffer + len - p, "-%02X", res_path[i]);
1325 * ipr_format_res_path - Format the resource path for printing.
1326 * @ioa_cfg: ioa config struct
1327 * @res_path: resource path
1329 * @len: length of buffer provided
1334 static char *ipr_format_res_path(struct ipr_ioa_cfg *ioa_cfg,
1335 u8 *res_path, char *buffer, int len)
1340 p += snprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no);
1341 __ipr_format_res_path(res_path, p, len - (buffer - p));
1346 * ipr_update_res_entry - Update the resource entry.
1347 * @res: resource entry struct
1348 * @cfgtew: config table entry wrapper struct
1353 static void ipr_update_res_entry(struct ipr_resource_entry *res,
1354 struct ipr_config_table_entry_wrapper *cfgtew)
1356 char buffer[IPR_MAX_RES_PATH_LENGTH];
1360 if (res->ioa_cfg->sis64) {
1361 res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
1362 res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
1363 res->type = cfgtew->u.cfgte64->res_type;
1365 memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1366 sizeof(struct ipr_std_inq_data));
1368 res->qmodel = IPR_QUEUEING_MODEL64(res);
1369 proto = cfgtew->u.cfgte64->proto;
1370 res->res_handle = cfgtew->u.cfgte64->res_handle;
1371 res->dev_id = cfgtew->u.cfgte64->dev_id;
1373 memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1374 sizeof(res->dev_lun.scsi_lun));
1376 if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
1377 sizeof(res->res_path))) {
1378 memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1379 sizeof(res->res_path));
1383 if (res->sdev && new_path)
1384 sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
1385 ipr_format_res_path(res->ioa_cfg,
1386 res->res_path, buffer, sizeof(buffer)));
1388 res->flags = cfgtew->u.cfgte->flags;
1389 if (res->flags & IPR_IS_IOA_RESOURCE)
1390 res->type = IPR_RES_TYPE_IOAFP;
1392 res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1394 memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1395 sizeof(struct ipr_std_inq_data));
1397 res->qmodel = IPR_QUEUEING_MODEL(res);
1398 proto = cfgtew->u.cfgte->proto;
1399 res->res_handle = cfgtew->u.cfgte->res_handle;
1402 ipr_update_ata_class(res, proto);
1406 * ipr_clear_res_target - Clear the bit in the bit map representing the target
1408 * @res: resource entry struct
1409 * @cfgtew: config table entry wrapper struct
1414 static void ipr_clear_res_target(struct ipr_resource_entry *res)
1416 struct ipr_resource_entry *gscsi_res = NULL;
1417 struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1419 if (!ioa_cfg->sis64)
1422 if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
1423 clear_bit(res->target, ioa_cfg->array_ids);
1424 else if (res->bus == IPR_VSET_VIRTUAL_BUS)
1425 clear_bit(res->target, ioa_cfg->vset_ids);
1426 else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1427 list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
1428 if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
1430 clear_bit(res->target, ioa_cfg->target_ids);
1432 } else if (res->bus == 0)
1433 clear_bit(res->target, ioa_cfg->target_ids);
1437 * ipr_handle_config_change - Handle a config change from the adapter
1438 * @ioa_cfg: ioa config struct
1444 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1445 struct ipr_hostrcb *hostrcb)
1447 struct ipr_resource_entry *res = NULL;
1448 struct ipr_config_table_entry_wrapper cfgtew;
1449 __be32 cc_res_handle;
1453 if (ioa_cfg->sis64) {
1454 cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1455 cc_res_handle = cfgtew.u.cfgte64->res_handle;
1457 cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1458 cc_res_handle = cfgtew.u.cfgte->res_handle;
1461 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1462 if (res->res_handle == cc_res_handle) {
1469 if (list_empty(&ioa_cfg->free_res_q)) {
1470 ipr_send_hcam(ioa_cfg,
1471 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1476 res = list_entry(ioa_cfg->free_res_q.next,
1477 struct ipr_resource_entry, queue);
1479 list_del(&res->queue);
1480 ipr_init_res_entry(res, &cfgtew);
1481 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1484 ipr_update_res_entry(res, &cfgtew);
1486 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1488 res->del_from_ml = 1;
1489 res->res_handle = IPR_INVALID_RES_HANDLE;
1490 schedule_work(&ioa_cfg->work_q);
1492 ipr_clear_res_target(res);
1493 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1495 } else if (!res->sdev || res->del_from_ml) {
1497 schedule_work(&ioa_cfg->work_q);
1500 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1504 * ipr_process_ccn - Op done function for a CCN.
1505 * @ipr_cmd: ipr command struct
1507 * This function is the op done function for a configuration
1508 * change notification host controlled async from the adapter.
1513 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
1515 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1516 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1517 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
1519 list_del_init(&hostrcb->queue);
1520 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
1523 if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
1524 ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST)
1525 dev_err(&ioa_cfg->pdev->dev,
1526 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1528 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1530 ipr_handle_config_change(ioa_cfg, hostrcb);
1535 * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1536 * @i: index into buffer
1537 * @buf: string to modify
1539 * This function will strip all trailing whitespace, pad the end
1540 * of the string with a single space, and NULL terminate the string.
1543 * new length of string
1545 static int strip_and_pad_whitespace(int i, char *buf)
1547 while (i && buf[i] == ' ')
1555 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1556 * @prefix: string to print at start of printk
1557 * @hostrcb: hostrcb pointer
1558 * @vpd: vendor/product id/sn struct
1563 static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1564 struct ipr_vpd *vpd)
1566 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
1569 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1570 i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
1572 memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
1573 i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
1575 memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
1576 buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
1578 ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
1582 * ipr_log_vpd - Log the passed VPD to the error log.
1583 * @vpd: vendor/product id/sn struct
1588 static void ipr_log_vpd(struct ipr_vpd *vpd)
1590 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1591 + IPR_SERIAL_NUM_LEN];
1593 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1594 memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1596 buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1597 ipr_err("Vendor/Product ID: %s\n", buffer);
1599 memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1600 buffer[IPR_SERIAL_NUM_LEN] = '\0';
1601 ipr_err(" Serial Number: %s\n", buffer);
1605 * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1606 * @prefix: string to print at start of printk
1607 * @hostrcb: hostrcb pointer
1608 * @vpd: vendor/product id/sn/wwn struct
1613 static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1614 struct ipr_ext_vpd *vpd)
1616 ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1617 ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1618 be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1622 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1623 * @vpd: vendor/product id/sn/wwn struct
1628 static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1630 ipr_log_vpd(&vpd->vpd);
1631 ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1632 be32_to_cpu(vpd->wwid[1]));
1636 * ipr_log_enhanced_cache_error - Log a cache error.
1637 * @ioa_cfg: ioa config struct
1638 * @hostrcb: hostrcb struct
1643 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1644 struct ipr_hostrcb *hostrcb)
1646 struct ipr_hostrcb_type_12_error *error;
1649 error = &hostrcb->hcam.u.error64.u.type_12_error;
1651 error = &hostrcb->hcam.u.error.u.type_12_error;
1653 ipr_err("-----Current Configuration-----\n");
1654 ipr_err("Cache Directory Card Information:\n");
1655 ipr_log_ext_vpd(&error->ioa_vpd);
1656 ipr_err("Adapter Card Information:\n");
1657 ipr_log_ext_vpd(&error->cfc_vpd);
1659 ipr_err("-----Expected Configuration-----\n");
1660 ipr_err("Cache Directory Card Information:\n");
1661 ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1662 ipr_err("Adapter Card Information:\n");
1663 ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1665 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1666 be32_to_cpu(error->ioa_data[0]),
1667 be32_to_cpu(error->ioa_data[1]),
1668 be32_to_cpu(error->ioa_data[2]));
1672 * ipr_log_cache_error - Log a cache error.
1673 * @ioa_cfg: ioa config struct
1674 * @hostrcb: hostrcb struct
1679 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1680 struct ipr_hostrcb *hostrcb)
1682 struct ipr_hostrcb_type_02_error *error =
1683 &hostrcb->hcam.u.error.u.type_02_error;
1685 ipr_err("-----Current Configuration-----\n");
1686 ipr_err("Cache Directory Card Information:\n");
1687 ipr_log_vpd(&error->ioa_vpd);
1688 ipr_err("Adapter Card Information:\n");
1689 ipr_log_vpd(&error->cfc_vpd);
1691 ipr_err("-----Expected Configuration-----\n");
1692 ipr_err("Cache Directory Card Information:\n");
1693 ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1694 ipr_err("Adapter Card Information:\n");
1695 ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1697 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1698 be32_to_cpu(error->ioa_data[0]),
1699 be32_to_cpu(error->ioa_data[1]),
1700 be32_to_cpu(error->ioa_data[2]));
1704 * ipr_log_enhanced_config_error - Log a configuration error.
1705 * @ioa_cfg: ioa config struct
1706 * @hostrcb: hostrcb struct
1711 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1712 struct ipr_hostrcb *hostrcb)
1714 int errors_logged, i;
1715 struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1716 struct ipr_hostrcb_type_13_error *error;
1718 error = &hostrcb->hcam.u.error.u.type_13_error;
1719 errors_logged = be32_to_cpu(error->errors_logged);
1721 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1722 be32_to_cpu(error->errors_detected), errors_logged);
1724 dev_entry = error->dev;
1726 for (i = 0; i < errors_logged; i++, dev_entry++) {
1729 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1730 ipr_log_ext_vpd(&dev_entry->vpd);
1732 ipr_err("-----New Device Information-----\n");
1733 ipr_log_ext_vpd(&dev_entry->new_vpd);
1735 ipr_err("Cache Directory Card Information:\n");
1736 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1738 ipr_err("Adapter Card Information:\n");
1739 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1744 * ipr_log_sis64_config_error - Log a device error.
1745 * @ioa_cfg: ioa config struct
1746 * @hostrcb: hostrcb struct
1751 static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1752 struct ipr_hostrcb *hostrcb)
1754 int errors_logged, i;
1755 struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1756 struct ipr_hostrcb_type_23_error *error;
1757 char buffer[IPR_MAX_RES_PATH_LENGTH];
1759 error = &hostrcb->hcam.u.error64.u.type_23_error;
1760 errors_logged = be32_to_cpu(error->errors_logged);
1762 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1763 be32_to_cpu(error->errors_detected), errors_logged);
1765 dev_entry = error->dev;
1767 for (i = 0; i < errors_logged; i++, dev_entry++) {
1770 ipr_err("Device %d : %s", i + 1,
1771 __ipr_format_res_path(dev_entry->res_path,
1772 buffer, sizeof(buffer)));
1773 ipr_log_ext_vpd(&dev_entry->vpd);
1775 ipr_err("-----New Device Information-----\n");
1776 ipr_log_ext_vpd(&dev_entry->new_vpd);
1778 ipr_err("Cache Directory Card Information:\n");
1779 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1781 ipr_err("Adapter Card Information:\n");
1782 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1787 * ipr_log_config_error - Log a configuration error.
1788 * @ioa_cfg: ioa config struct
1789 * @hostrcb: hostrcb struct
1794 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1795 struct ipr_hostrcb *hostrcb)
1797 int errors_logged, i;
1798 struct ipr_hostrcb_device_data_entry *dev_entry;
1799 struct ipr_hostrcb_type_03_error *error;
1801 error = &hostrcb->hcam.u.error.u.type_03_error;
1802 errors_logged = be32_to_cpu(error->errors_logged);
1804 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1805 be32_to_cpu(error->errors_detected), errors_logged);
1807 dev_entry = error->dev;
1809 for (i = 0; i < errors_logged; i++, dev_entry++) {
1812 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1813 ipr_log_vpd(&dev_entry->vpd);
1815 ipr_err("-----New Device Information-----\n");
1816 ipr_log_vpd(&dev_entry->new_vpd);
1818 ipr_err("Cache Directory Card Information:\n");
1819 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1821 ipr_err("Adapter Card Information:\n");
1822 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1824 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1825 be32_to_cpu(dev_entry->ioa_data[0]),
1826 be32_to_cpu(dev_entry->ioa_data[1]),
1827 be32_to_cpu(dev_entry->ioa_data[2]),
1828 be32_to_cpu(dev_entry->ioa_data[3]),
1829 be32_to_cpu(dev_entry->ioa_data[4]));
1834 * ipr_log_enhanced_array_error - Log an array configuration error.
1835 * @ioa_cfg: ioa config struct
1836 * @hostrcb: hostrcb struct
1841 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1842 struct ipr_hostrcb *hostrcb)
1845 struct ipr_hostrcb_type_14_error *error;
1846 struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1847 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1849 error = &hostrcb->hcam.u.error.u.type_14_error;
1853 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1854 error->protection_level,
1855 ioa_cfg->host->host_no,
1856 error->last_func_vset_res_addr.bus,
1857 error->last_func_vset_res_addr.target,
1858 error->last_func_vset_res_addr.lun);
1862 array_entry = error->array_member;
1863 num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1864 ARRAY_SIZE(error->array_member));
1866 for (i = 0; i < num_entries; i++, array_entry++) {
1867 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1870 if (be32_to_cpu(error->exposed_mode_adn) == i)
1871 ipr_err("Exposed Array Member %d:\n", i);
1873 ipr_err("Array Member %d:\n", i);
1875 ipr_log_ext_vpd(&array_entry->vpd);
1876 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1877 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1878 "Expected Location");
1885 * ipr_log_array_error - Log an array configuration error.
1886 * @ioa_cfg: ioa config struct
1887 * @hostrcb: hostrcb struct
1892 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1893 struct ipr_hostrcb *hostrcb)
1896 struct ipr_hostrcb_type_04_error *error;
1897 struct ipr_hostrcb_array_data_entry *array_entry;
1898 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1900 error = &hostrcb->hcam.u.error.u.type_04_error;
1904 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1905 error->protection_level,
1906 ioa_cfg->host->host_no,
1907 error->last_func_vset_res_addr.bus,
1908 error->last_func_vset_res_addr.target,
1909 error->last_func_vset_res_addr.lun);
1913 array_entry = error->array_member;
1915 for (i = 0; i < 18; i++) {
1916 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1919 if (be32_to_cpu(error->exposed_mode_adn) == i)
1920 ipr_err("Exposed Array Member %d:\n", i);
1922 ipr_err("Array Member %d:\n", i);
1924 ipr_log_vpd(&array_entry->vpd);
1926 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1927 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1928 "Expected Location");
1933 array_entry = error->array_member2;
1940 * ipr_log_hex_data - Log additional hex IOA error data.
1941 * @ioa_cfg: ioa config struct
1942 * @data: IOA error data
1948 static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, __be32 *data, int len)
1955 if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1956 len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1958 for (i = 0; i < len / 4; i += 4) {
1959 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1960 be32_to_cpu(data[i]),
1961 be32_to_cpu(data[i+1]),
1962 be32_to_cpu(data[i+2]),
1963 be32_to_cpu(data[i+3]));
1968 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1969 * @ioa_cfg: ioa config struct
1970 * @hostrcb: hostrcb struct
1975 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1976 struct ipr_hostrcb *hostrcb)
1978 struct ipr_hostrcb_type_17_error *error;
1981 error = &hostrcb->hcam.u.error64.u.type_17_error;
1983 error = &hostrcb->hcam.u.error.u.type_17_error;
1985 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1986 strim(error->failure_reason);
1988 ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1989 be32_to_cpu(hostrcb->hcam.u.error.prc));
1990 ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1991 ipr_log_hex_data(ioa_cfg, error->data,
1992 be32_to_cpu(hostrcb->hcam.length) -
1993 (offsetof(struct ipr_hostrcb_error, u) +
1994 offsetof(struct ipr_hostrcb_type_17_error, data)));
1998 * ipr_log_dual_ioa_error - Log a dual adapter error.
1999 * @ioa_cfg: ioa config struct
2000 * @hostrcb: hostrcb struct
2005 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
2006 struct ipr_hostrcb *hostrcb)
2008 struct ipr_hostrcb_type_07_error *error;
2010 error = &hostrcb->hcam.u.error.u.type_07_error;
2011 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2012 strim(error->failure_reason);
2014 ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
2015 be32_to_cpu(hostrcb->hcam.u.error.prc));
2016 ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
2017 ipr_log_hex_data(ioa_cfg, error->data,
2018 be32_to_cpu(hostrcb->hcam.length) -
2019 (offsetof(struct ipr_hostrcb_error, u) +
2020 offsetof(struct ipr_hostrcb_type_07_error, data)));
2023 static const struct {
2026 } path_active_desc[] = {
2027 { IPR_PATH_NO_INFO, "Path" },
2028 { IPR_PATH_ACTIVE, "Active path" },
2029 { IPR_PATH_NOT_ACTIVE, "Inactive path" }
2032 static const struct {
2035 } path_state_desc[] = {
2036 { IPR_PATH_STATE_NO_INFO, "has no path state information available" },
2037 { IPR_PATH_HEALTHY, "is healthy" },
2038 { IPR_PATH_DEGRADED, "is degraded" },
2039 { IPR_PATH_FAILED, "is failed" }
2043 * ipr_log_fabric_path - Log a fabric path error
2044 * @hostrcb: hostrcb struct
2045 * @fabric: fabric descriptor
2050 static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
2051 struct ipr_hostrcb_fabric_desc *fabric)
2054 u8 path_state = fabric->path_state;
2055 u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2056 u8 state = path_state & IPR_PATH_STATE_MASK;
2058 for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2059 if (path_active_desc[i].active != active)
2062 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2063 if (path_state_desc[j].state != state)
2066 if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
2067 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
2068 path_active_desc[i].desc, path_state_desc[j].desc,
2070 } else if (fabric->cascaded_expander == 0xff) {
2071 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
2072 path_active_desc[i].desc, path_state_desc[j].desc,
2073 fabric->ioa_port, fabric->phy);
2074 } else if (fabric->phy == 0xff) {
2075 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
2076 path_active_desc[i].desc, path_state_desc[j].desc,
2077 fabric->ioa_port, fabric->cascaded_expander);
2079 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
2080 path_active_desc[i].desc, path_state_desc[j].desc,
2081 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2087 ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
2088 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
2092 * ipr_log64_fabric_path - Log a fabric path error
2093 * @hostrcb: hostrcb struct
2094 * @fabric: fabric descriptor
2099 static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
2100 struct ipr_hostrcb64_fabric_desc *fabric)
2103 u8 path_state = fabric->path_state;
2104 u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2105 u8 state = path_state & IPR_PATH_STATE_MASK;
2106 char buffer[IPR_MAX_RES_PATH_LENGTH];
2108 for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2109 if (path_active_desc[i].active != active)
2112 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2113 if (path_state_desc[j].state != state)
2116 ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
2117 path_active_desc[i].desc, path_state_desc[j].desc,
2118 ipr_format_res_path(hostrcb->ioa_cfg,
2120 buffer, sizeof(buffer)));
2125 ipr_err("Path state=%02X Resource Path=%s\n", path_state,
2126 ipr_format_res_path(hostrcb->ioa_cfg, fabric->res_path,
2127 buffer, sizeof(buffer)));
2130 static const struct {
2133 } path_type_desc[] = {
2134 { IPR_PATH_CFG_IOA_PORT, "IOA port" },
2135 { IPR_PATH_CFG_EXP_PORT, "Expander port" },
2136 { IPR_PATH_CFG_DEVICE_PORT, "Device port" },
2137 { IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
2140 static const struct {
2143 } path_status_desc[] = {
2144 { IPR_PATH_CFG_NO_PROB, "Functional" },
2145 { IPR_PATH_CFG_DEGRADED, "Degraded" },
2146 { IPR_PATH_CFG_FAILED, "Failed" },
2147 { IPR_PATH_CFG_SUSPECT, "Suspect" },
2148 { IPR_PATH_NOT_DETECTED, "Missing" },
2149 { IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
2152 static const char *link_rate[] = {
2155 "phy reset problem",
2172 * ipr_log_path_elem - Log a fabric path element.
2173 * @hostrcb: hostrcb struct
2174 * @cfg: fabric path element struct
2179 static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
2180 struct ipr_hostrcb_config_element *cfg)
2183 u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2184 u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2186 if (type == IPR_PATH_CFG_NOT_EXIST)
2189 for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2190 if (path_type_desc[i].type != type)
2193 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2194 if (path_status_desc[j].status != status)
2197 if (type == IPR_PATH_CFG_IOA_PORT) {
2198 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2199 path_status_desc[j].desc, path_type_desc[i].desc,
2200 cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2201 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2203 if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2204 ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2205 path_status_desc[j].desc, path_type_desc[i].desc,
2206 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2207 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2208 } else if (cfg->cascaded_expander == 0xff) {
2209 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2210 "WWN=%08X%08X\n", path_status_desc[j].desc,
2211 path_type_desc[i].desc, cfg->phy,
2212 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2213 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2214 } else if (cfg->phy == 0xff) {
2215 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2216 "WWN=%08X%08X\n", path_status_desc[j].desc,
2217 path_type_desc[i].desc, cfg->cascaded_expander,
2218 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2219 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2221 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2222 "WWN=%08X%08X\n", path_status_desc[j].desc,
2223 path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2224 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2225 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2232 ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2233 "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2234 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2235 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2239 * ipr_log64_path_elem - Log a fabric path element.
2240 * @hostrcb: hostrcb struct
2241 * @cfg: fabric path element struct
2246 static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2247 struct ipr_hostrcb64_config_element *cfg)
2250 u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2251 u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2252 u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2253 char buffer[IPR_MAX_RES_PATH_LENGTH];
2255 if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2258 for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2259 if (path_type_desc[i].type != type)
2262 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2263 if (path_status_desc[j].status != status)
2266 ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2267 path_status_desc[j].desc, path_type_desc[i].desc,
2268 ipr_format_res_path(hostrcb->ioa_cfg,
2269 cfg->res_path, buffer, sizeof(buffer)),
2270 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2271 be32_to_cpu(cfg->wwid[0]),
2272 be32_to_cpu(cfg->wwid[1]));
2276 ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2277 "WWN=%08X%08X\n", cfg->type_status,
2278 ipr_format_res_path(hostrcb->ioa_cfg,
2279 cfg->res_path, buffer, sizeof(buffer)),
2280 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2281 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2285 * ipr_log_fabric_error - Log a fabric error.
2286 * @ioa_cfg: ioa config struct
2287 * @hostrcb: hostrcb struct
2292 static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2293 struct ipr_hostrcb *hostrcb)
2295 struct ipr_hostrcb_type_20_error *error;
2296 struct ipr_hostrcb_fabric_desc *fabric;
2297 struct ipr_hostrcb_config_element *cfg;
2300 error = &hostrcb->hcam.u.error.u.type_20_error;
2301 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2302 ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2304 add_len = be32_to_cpu(hostrcb->hcam.length) -
2305 (offsetof(struct ipr_hostrcb_error, u) +
2306 offsetof(struct ipr_hostrcb_type_20_error, desc));
2308 for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2309 ipr_log_fabric_path(hostrcb, fabric);
2310 for_each_fabric_cfg(fabric, cfg)
2311 ipr_log_path_elem(hostrcb, cfg);
2313 add_len -= be16_to_cpu(fabric->length);
2314 fabric = (struct ipr_hostrcb_fabric_desc *)
2315 ((unsigned long)fabric + be16_to_cpu(fabric->length));
2318 ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2322 * ipr_log_sis64_array_error - Log a sis64 array error.
2323 * @ioa_cfg: ioa config struct
2324 * @hostrcb: hostrcb struct
2329 static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2330 struct ipr_hostrcb *hostrcb)
2333 struct ipr_hostrcb_type_24_error *error;
2334 struct ipr_hostrcb64_array_data_entry *array_entry;
2335 char buffer[IPR_MAX_RES_PATH_LENGTH];
2336 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2338 error = &hostrcb->hcam.u.error64.u.type_24_error;
2342 ipr_err("RAID %s Array Configuration: %s\n",
2343 error->protection_level,
2344 ipr_format_res_path(ioa_cfg, error->last_res_path,
2345 buffer, sizeof(buffer)));
2349 array_entry = error->array_member;
2350 num_entries = min_t(u32, error->num_entries,
2351 ARRAY_SIZE(error->array_member));
2353 for (i = 0; i < num_entries; i++, array_entry++) {
2355 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2358 if (error->exposed_mode_adn == i)
2359 ipr_err("Exposed Array Member %d:\n", i);
2361 ipr_err("Array Member %d:\n", i);
2363 ipr_err("Array Member %d:\n", i);
2364 ipr_log_ext_vpd(&array_entry->vpd);
2365 ipr_err("Current Location: %s\n",
2366 ipr_format_res_path(ioa_cfg, array_entry->res_path,
2367 buffer, sizeof(buffer)));
2368 ipr_err("Expected Location: %s\n",
2369 ipr_format_res_path(ioa_cfg,
2370 array_entry->expected_res_path,
2371 buffer, sizeof(buffer)));
2378 * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2379 * @ioa_cfg: ioa config struct
2380 * @hostrcb: hostrcb struct
2385 static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2386 struct ipr_hostrcb *hostrcb)
2388 struct ipr_hostrcb_type_30_error *error;
2389 struct ipr_hostrcb64_fabric_desc *fabric;
2390 struct ipr_hostrcb64_config_element *cfg;
2393 error = &hostrcb->hcam.u.error64.u.type_30_error;
2395 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2396 ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2398 add_len = be32_to_cpu(hostrcb->hcam.length) -
2399 (offsetof(struct ipr_hostrcb64_error, u) +
2400 offsetof(struct ipr_hostrcb_type_30_error, desc));
2402 for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2403 ipr_log64_fabric_path(hostrcb, fabric);
2404 for_each_fabric_cfg(fabric, cfg)
2405 ipr_log64_path_elem(hostrcb, cfg);
2407 add_len -= be16_to_cpu(fabric->length);
2408 fabric = (struct ipr_hostrcb64_fabric_desc *)
2409 ((unsigned long)fabric + be16_to_cpu(fabric->length));
2412 ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
2416 * ipr_log_sis64_service_required_error - Log a sis64 service required error.
2417 * @ioa_cfg: ioa config struct
2418 * @hostrcb: hostrcb struct
2423 static void ipr_log_sis64_service_required_error(struct ipr_ioa_cfg *ioa_cfg,
2424 struct ipr_hostrcb *hostrcb)
2426 struct ipr_hostrcb_type_41_error *error;
2428 error = &hostrcb->hcam.u.error64.u.type_41_error;
2430 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2431 ipr_err("Primary Failure Reason: %s\n", error->failure_reason);
2432 ipr_log_hex_data(ioa_cfg, error->data,
2433 be32_to_cpu(hostrcb->hcam.length) -
2434 (offsetof(struct ipr_hostrcb_error, u) +
2435 offsetof(struct ipr_hostrcb_type_41_error, data)));
2438 * ipr_log_generic_error - Log an adapter error.
2439 * @ioa_cfg: ioa config struct
2440 * @hostrcb: hostrcb struct
2445 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2446 struct ipr_hostrcb *hostrcb)
2448 ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2449 be32_to_cpu(hostrcb->hcam.length));
2453 * ipr_log_sis64_device_error - Log a cache error.
2454 * @ioa_cfg: ioa config struct
2455 * @hostrcb: hostrcb struct
2460 static void ipr_log_sis64_device_error(struct ipr_ioa_cfg *ioa_cfg,
2461 struct ipr_hostrcb *hostrcb)
2463 struct ipr_hostrcb_type_21_error *error;
2464 char buffer[IPR_MAX_RES_PATH_LENGTH];
2466 error = &hostrcb->hcam.u.error64.u.type_21_error;
2468 ipr_err("-----Failing Device Information-----\n");
2469 ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
2470 be32_to_cpu(error->wwn[0]), be32_to_cpu(error->wwn[1]),
2471 be32_to_cpu(error->wwn[2]), be32_to_cpu(error->wwn[3]));
2472 ipr_err("Device Resource Path: %s\n",
2473 __ipr_format_res_path(error->res_path,
2474 buffer, sizeof(buffer)));
2475 error->primary_problem_desc[sizeof(error->primary_problem_desc) - 1] = '\0';
2476 error->second_problem_desc[sizeof(error->second_problem_desc) - 1] = '\0';
2477 ipr_err("Primary Problem Description: %s\n", error->primary_problem_desc);
2478 ipr_err("Secondary Problem Description: %s\n", error->second_problem_desc);
2479 ipr_err("SCSI Sense Data:\n");
2480 ipr_log_hex_data(ioa_cfg, error->sense_data, sizeof(error->sense_data));
2481 ipr_err("SCSI Command Descriptor Block: \n");
2482 ipr_log_hex_data(ioa_cfg, error->cdb, sizeof(error->cdb));
2484 ipr_err("Additional IOA Data:\n");
2485 ipr_log_hex_data(ioa_cfg, error->ioa_data, be32_to_cpu(error->length_of_error));
2489 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2492 * This function will return the index of into the ipr_error_table
2493 * for the specified IOASC. If the IOASC is not in the table,
2494 * 0 will be returned, which points to the entry used for unknown errors.
2497 * index into the ipr_error_table
2499 static u32 ipr_get_error(u32 ioasc)
2503 for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2504 if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2511 * ipr_handle_log_data - Log an adapter error.
2512 * @ioa_cfg: ioa config struct
2513 * @hostrcb: hostrcb struct
2515 * This function logs an adapter error to the system.
2520 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2521 struct ipr_hostrcb *hostrcb)
2525 struct ipr_hostrcb_type_21_error *error;
2527 if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2530 if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2531 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2534 ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2536 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2538 if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2539 ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2540 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2541 scsi_report_bus_reset(ioa_cfg->host,
2542 hostrcb->hcam.u.error.fd_res_addr.bus);
2545 error_index = ipr_get_error(ioasc);
2547 if (!ipr_error_table[error_index].log_hcam)
2550 if (ioasc == IPR_IOASC_HW_CMD_FAILED &&
2551 hostrcb->hcam.overlay_id == IPR_HOST_RCB_OVERLAY_ID_21) {
2552 error = &hostrcb->hcam.u.error64.u.type_21_error;
2554 if (((be32_to_cpu(error->sense_data[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST &&
2555 ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
2559 ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2561 /* Set indication we have logged an error */
2562 ioa_cfg->errors_logged++;
2564 if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2566 if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2567 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2569 switch (hostrcb->hcam.overlay_id) {
2570 case IPR_HOST_RCB_OVERLAY_ID_2:
2571 ipr_log_cache_error(ioa_cfg, hostrcb);
2573 case IPR_HOST_RCB_OVERLAY_ID_3:
2574 ipr_log_config_error(ioa_cfg, hostrcb);
2576 case IPR_HOST_RCB_OVERLAY_ID_4:
2577 case IPR_HOST_RCB_OVERLAY_ID_6:
2578 ipr_log_array_error(ioa_cfg, hostrcb);
2580 case IPR_HOST_RCB_OVERLAY_ID_7:
2581 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2583 case IPR_HOST_RCB_OVERLAY_ID_12:
2584 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2586 case IPR_HOST_RCB_OVERLAY_ID_13:
2587 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2589 case IPR_HOST_RCB_OVERLAY_ID_14:
2590 case IPR_HOST_RCB_OVERLAY_ID_16:
2591 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2593 case IPR_HOST_RCB_OVERLAY_ID_17:
2594 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2596 case IPR_HOST_RCB_OVERLAY_ID_20:
2597 ipr_log_fabric_error(ioa_cfg, hostrcb);
2599 case IPR_HOST_RCB_OVERLAY_ID_21:
2600 ipr_log_sis64_device_error(ioa_cfg, hostrcb);
2602 case IPR_HOST_RCB_OVERLAY_ID_23:
2603 ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2605 case IPR_HOST_RCB_OVERLAY_ID_24:
2606 case IPR_HOST_RCB_OVERLAY_ID_26:
2607 ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2609 case IPR_HOST_RCB_OVERLAY_ID_30:
2610 ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2612 case IPR_HOST_RCB_OVERLAY_ID_41:
2613 ipr_log_sis64_service_required_error(ioa_cfg, hostrcb);
2615 case IPR_HOST_RCB_OVERLAY_ID_1:
2616 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2618 ipr_log_generic_error(ioa_cfg, hostrcb);
2623 static struct ipr_hostrcb *ipr_get_free_hostrcb(struct ipr_ioa_cfg *ioa)
2625 struct ipr_hostrcb *hostrcb;
2627 hostrcb = list_first_entry_or_null(&ioa->hostrcb_free_q,
2628 struct ipr_hostrcb, queue);
2630 if (unlikely(!hostrcb)) {
2631 dev_info(&ioa->pdev->dev, "Reclaiming async error buffers.");
2632 hostrcb = list_first_entry_or_null(&ioa->hostrcb_report_q,
2633 struct ipr_hostrcb, queue);
2636 list_del_init(&hostrcb->queue);
2641 * ipr_process_error - Op done function for an adapter error log.
2642 * @ipr_cmd: ipr command struct
2644 * This function is the op done function for an error log host
2645 * controlled async from the adapter. It will log the error and
2646 * send the HCAM back to the adapter.
2651 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2653 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2654 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2655 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2659 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2661 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2663 list_del_init(&hostrcb->queue);
2664 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
2667 ipr_handle_log_data(ioa_cfg, hostrcb);
2668 if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2669 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2670 } else if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
2671 ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) {
2672 dev_err(&ioa_cfg->pdev->dev,
2673 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
2676 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_report_q);
2677 schedule_work(&ioa_cfg->work_q);
2678 hostrcb = ipr_get_free_hostrcb(ioa_cfg);
2680 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2684 * ipr_timeout - An internally generated op has timed out.
2685 * @ipr_cmd: ipr command struct
2687 * This function blocks host requests and initiates an
2693 static void ipr_timeout(struct timer_list *t)
2695 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2696 unsigned long lock_flags = 0;
2697 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2700 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2702 ioa_cfg->errors_logged++;
2703 dev_err(&ioa_cfg->pdev->dev,
2704 "Adapter being reset due to command timeout.\n");
2706 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2707 ioa_cfg->sdt_state = GET_DUMP;
2709 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2710 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2712 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2717 * ipr_oper_timeout - Adapter timed out transitioning to operational
2718 * @ipr_cmd: ipr command struct
2720 * This function blocks host requests and initiates an
2726 static void ipr_oper_timeout(struct timer_list *t)
2728 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2729 unsigned long lock_flags = 0;
2730 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2733 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2735 ioa_cfg->errors_logged++;
2736 dev_err(&ioa_cfg->pdev->dev,
2737 "Adapter timed out transitioning to operational.\n");
2739 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2740 ioa_cfg->sdt_state = GET_DUMP;
2742 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2744 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2745 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2748 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2753 * ipr_find_ses_entry - Find matching SES in SES table
2754 * @res: resource entry struct of SES
2757 * pointer to SES table entry / NULL on failure
2759 static const struct ipr_ses_table_entry *
2760 ipr_find_ses_entry(struct ipr_resource_entry *res)
2763 struct ipr_std_inq_vpids *vpids;
2764 const struct ipr_ses_table_entry *ste = ipr_ses_table;
2766 for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2767 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2768 if (ste->compare_product_id_byte[j] == 'X') {
2769 vpids = &res->std_inq_data.vpids;
2770 if (vpids->product_id[j] == ste->product_id[j])
2778 if (matches == IPR_PROD_ID_LEN)
2786 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2787 * @ioa_cfg: ioa config struct
2789 * @bus_width: bus width
2792 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2793 * For a 2-byte wide SCSI bus, the maximum transfer speed is
2794 * twice the maximum transfer rate (e.g. for a wide enabled bus,
2795 * max 160MHz = max 320MB/sec).
2797 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2799 struct ipr_resource_entry *res;
2800 const struct ipr_ses_table_entry *ste;
2801 u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2803 /* Loop through each config table entry in the config table buffer */
2804 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2805 if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2808 if (bus != res->bus)
2811 if (!(ste = ipr_find_ses_entry(res)))
2814 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2817 return max_xfer_rate;
2821 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2822 * @ioa_cfg: ioa config struct
2823 * @max_delay: max delay in micro-seconds to wait
2825 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2828 * 0 on success / other on failure
2830 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2832 volatile u32 pcii_reg;
2835 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2836 while (delay < max_delay) {
2837 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2839 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2842 /* udelay cannot be used if delay is more than a few milliseconds */
2843 if ((delay / 1000) > MAX_UDELAY_MS)
2844 mdelay(delay / 1000);
2854 * ipr_get_sis64_dump_data_section - Dump IOA memory
2855 * @ioa_cfg: ioa config struct
2856 * @start_addr: adapter address to dump
2857 * @dest: destination kernel buffer
2858 * @length_in_words: length to dump in 4 byte words
2863 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2865 __be32 *dest, u32 length_in_words)
2869 for (i = 0; i < length_in_words; i++) {
2870 writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2871 *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2879 * ipr_get_ldump_data_section - Dump IOA memory
2880 * @ioa_cfg: ioa config struct
2881 * @start_addr: adapter address to dump
2882 * @dest: destination kernel buffer
2883 * @length_in_words: length to dump in 4 byte words
2886 * 0 on success / -EIO on failure
2888 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2890 __be32 *dest, u32 length_in_words)
2892 volatile u32 temp_pcii_reg;
2896 return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2897 dest, length_in_words);
2899 /* Write IOA interrupt reg starting LDUMP state */
2900 writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2901 ioa_cfg->regs.set_uproc_interrupt_reg32);
2903 /* Wait for IO debug acknowledge */
2904 if (ipr_wait_iodbg_ack(ioa_cfg,
2905 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2906 dev_err(&ioa_cfg->pdev->dev,
2907 "IOA dump long data transfer timeout\n");
2911 /* Signal LDUMP interlocked - clear IO debug ack */
2912 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2913 ioa_cfg->regs.clr_interrupt_reg);
2915 /* Write Mailbox with starting address */
2916 writel(start_addr, ioa_cfg->ioa_mailbox);
2918 /* Signal address valid - clear IOA Reset alert */
2919 writel(IPR_UPROCI_RESET_ALERT,
2920 ioa_cfg->regs.clr_uproc_interrupt_reg32);
2922 for (i = 0; i < length_in_words; i++) {
2923 /* Wait for IO debug acknowledge */
2924 if (ipr_wait_iodbg_ack(ioa_cfg,
2925 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2926 dev_err(&ioa_cfg->pdev->dev,
2927 "IOA dump short data transfer timeout\n");
2931 /* Read data from mailbox and increment destination pointer */
2932 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2935 /* For all but the last word of data, signal data received */
2936 if (i < (length_in_words - 1)) {
2937 /* Signal dump data received - Clear IO debug Ack */
2938 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2939 ioa_cfg->regs.clr_interrupt_reg);
2943 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2944 writel(IPR_UPROCI_RESET_ALERT,
2945 ioa_cfg->regs.set_uproc_interrupt_reg32);
2947 writel(IPR_UPROCI_IO_DEBUG_ALERT,
2948 ioa_cfg->regs.clr_uproc_interrupt_reg32);
2950 /* Signal dump data received - Clear IO debug Ack */
2951 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2952 ioa_cfg->regs.clr_interrupt_reg);
2954 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2955 while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2957 readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2959 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2969 #ifdef CONFIG_SCSI_IPR_DUMP
2971 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2972 * @ioa_cfg: ioa config struct
2973 * @pci_address: adapter address
2974 * @length: length of data to copy
2976 * Copy data from PCI adapter to kernel buffer.
2977 * Note: length MUST be a 4 byte multiple
2979 * 0 on success / other on failure
2981 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2982 unsigned long pci_address, u32 length)
2984 int bytes_copied = 0;
2985 int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2987 unsigned long lock_flags = 0;
2988 struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2991 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2993 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2995 while (bytes_copied < length &&
2996 (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2997 if (ioa_dump->page_offset >= PAGE_SIZE ||
2998 ioa_dump->page_offset == 0) {
2999 page = (__be32 *)__get_free_page(GFP_ATOMIC);
3003 return bytes_copied;
3006 ioa_dump->page_offset = 0;
3007 ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
3008 ioa_dump->next_page_index++;
3010 page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
3012 rem_len = length - bytes_copied;
3013 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
3014 cur_len = min(rem_len, rem_page_len);
3016 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3017 if (ioa_cfg->sdt_state == ABORT_DUMP) {
3020 rc = ipr_get_ldump_data_section(ioa_cfg,
3021 pci_address + bytes_copied,
3022 &page[ioa_dump->page_offset / 4],
3023 (cur_len / sizeof(u32)));
3025 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3028 ioa_dump->page_offset += cur_len;
3029 bytes_copied += cur_len;
3037 return bytes_copied;
3041 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
3042 * @hdr: dump entry header struct
3047 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
3049 hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
3051 hdr->offset = sizeof(*hdr);
3052 hdr->status = IPR_DUMP_STATUS_SUCCESS;
3056 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
3057 * @ioa_cfg: ioa config struct
3058 * @driver_dump: driver dump struct
3063 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
3064 struct ipr_driver_dump *driver_dump)
3066 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3068 ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
3069 driver_dump->ioa_type_entry.hdr.len =
3070 sizeof(struct ipr_dump_ioa_type_entry) -
3071 sizeof(struct ipr_dump_entry_header);
3072 driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3073 driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
3074 driver_dump->ioa_type_entry.type = ioa_cfg->type;
3075 driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
3076 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
3077 ucode_vpd->minor_release[1];
3078 driver_dump->hdr.num_entries++;
3082 * ipr_dump_version_data - Fill in the driver version in the dump.
3083 * @ioa_cfg: ioa config struct
3084 * @driver_dump: driver dump struct
3089 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
3090 struct ipr_driver_dump *driver_dump)
3092 ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
3093 driver_dump->version_entry.hdr.len =
3094 sizeof(struct ipr_dump_version_entry) -
3095 sizeof(struct ipr_dump_entry_header);
3096 driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3097 driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
3098 strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
3099 driver_dump->hdr.num_entries++;
3103 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
3104 * @ioa_cfg: ioa config struct
3105 * @driver_dump: driver dump struct
3110 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
3111 struct ipr_driver_dump *driver_dump)
3113 ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
3114 driver_dump->trace_entry.hdr.len =
3115 sizeof(struct ipr_dump_trace_entry) -
3116 sizeof(struct ipr_dump_entry_header);
3117 driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3118 driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
3119 memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
3120 driver_dump->hdr.num_entries++;
3124 * ipr_dump_location_data - Fill in the IOA location in the dump.
3125 * @ioa_cfg: ioa config struct
3126 * @driver_dump: driver dump struct
3131 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
3132 struct ipr_driver_dump *driver_dump)
3134 ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
3135 driver_dump->location_entry.hdr.len =
3136 sizeof(struct ipr_dump_location_entry) -
3137 sizeof(struct ipr_dump_entry_header);
3138 driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3139 driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
3140 strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
3141 driver_dump->hdr.num_entries++;
3145 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
3146 * @ioa_cfg: ioa config struct
3147 * @dump: dump struct
3152 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
3154 unsigned long start_addr, sdt_word;
3155 unsigned long lock_flags = 0;
3156 struct ipr_driver_dump *driver_dump = &dump->driver_dump;
3157 struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
3158 u32 num_entries, max_num_entries, start_off, end_off;
3159 u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
3160 struct ipr_sdt *sdt;
3166 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3168 if (ioa_cfg->sdt_state != READ_DUMP) {
3169 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3173 if (ioa_cfg->sis64) {
3174 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3175 ssleep(IPR_DUMP_DELAY_SECONDS);
3176 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3179 start_addr = readl(ioa_cfg->ioa_mailbox);
3181 if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
3182 dev_err(&ioa_cfg->pdev->dev,
3183 "Invalid dump table format: %lx\n", start_addr);
3184 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3188 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
3190 driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
3192 /* Initialize the overall dump header */
3193 driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
3194 driver_dump->hdr.num_entries = 1;
3195 driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
3196 driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
3197 driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
3198 driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
3200 ipr_dump_version_data(ioa_cfg, driver_dump);
3201 ipr_dump_location_data(ioa_cfg, driver_dump);
3202 ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
3203 ipr_dump_trace_data(ioa_cfg, driver_dump);
3205 /* Update dump_header */
3206 driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
3208 /* IOA Dump entry */
3209 ipr_init_dump_entry_hdr(&ioa_dump->hdr);
3210 ioa_dump->hdr.len = 0;
3211 ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3212 ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
3214 /* First entries in sdt are actually a list of dump addresses and
3215 lengths to gather the real dump data. sdt represents the pointer
3216 to the ioa generated dump table. Dump data will be extracted based
3217 on entries in this table */
3218 sdt = &ioa_dump->sdt;
3220 if (ioa_cfg->sis64) {
3221 max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
3222 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
3224 max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
3225 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
3228 bytes_to_copy = offsetof(struct ipr_sdt, entry) +
3229 (max_num_entries * sizeof(struct ipr_sdt_entry));
3230 rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
3231 bytes_to_copy / sizeof(__be32));
3233 /* Smart Dump table is ready to use and the first entry is valid */
3234 if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
3235 (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
3236 dev_err(&ioa_cfg->pdev->dev,
3237 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
3238 rc, be32_to_cpu(sdt->hdr.state));
3239 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
3240 ioa_cfg->sdt_state = DUMP_OBTAINED;
3241 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3245 num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
3247 if (num_entries > max_num_entries)
3248 num_entries = max_num_entries;
3250 /* Update dump length to the actual data to be copied */
3251 dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
3253 dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
3255 dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
3257 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3259 for (i = 0; i < num_entries; i++) {
3260 if (ioa_dump->hdr.len > max_dump_size) {
3261 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3265 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3266 sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3268 bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3270 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3271 end_off = be32_to_cpu(sdt->entry[i].end_token);
3273 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3274 bytes_to_copy = end_off - start_off;
3279 if (bytes_to_copy > max_dump_size) {
3280 sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3284 /* Copy data from adapter to driver buffers */
3285 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3288 ioa_dump->hdr.len += bytes_copied;
3290 if (bytes_copied != bytes_to_copy) {
3291 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3298 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3300 /* Update dump_header */
3301 driver_dump->hdr.len += ioa_dump->hdr.len;
3303 ioa_cfg->sdt_state = DUMP_OBTAINED;
3308 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3312 * ipr_release_dump - Free adapter dump memory
3313 * @kref: kref struct
3318 static void ipr_release_dump(struct kref *kref)
3320 struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3321 struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3322 unsigned long lock_flags = 0;
3326 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3327 ioa_cfg->dump = NULL;
3328 ioa_cfg->sdt_state = INACTIVE;
3329 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3331 for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3332 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3334 vfree(dump->ioa_dump.ioa_data);
3340 * ipr_worker_thread - Worker thread
3341 * @work: ioa config struct
3343 * Called at task level from a work thread. This function takes care
3344 * of adding and removing device from the mid-layer as configuration
3345 * changes are detected by the adapter.
3350 static void ipr_worker_thread(struct work_struct *work)
3352 unsigned long lock_flags;
3353 struct ipr_resource_entry *res;
3354 struct scsi_device *sdev;
3355 struct ipr_dump *dump;
3356 struct ipr_ioa_cfg *ioa_cfg =
3357 container_of(work, struct ipr_ioa_cfg, work_q);
3358 u8 bus, target, lun;
3362 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3364 if (ioa_cfg->sdt_state == READ_DUMP) {
3365 dump = ioa_cfg->dump;
3367 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3370 kref_get(&dump->kref);
3371 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3372 ipr_get_ioa_dump(ioa_cfg, dump);
3373 kref_put(&dump->kref, ipr_release_dump);
3375 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3376 if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3377 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3378 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3382 if (ioa_cfg->scsi_unblock) {
3383 ioa_cfg->scsi_unblock = 0;
3384 ioa_cfg->scsi_blocked = 0;
3385 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3386 scsi_unblock_requests(ioa_cfg->host);
3387 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3388 if (ioa_cfg->scsi_blocked)
3389 scsi_block_requests(ioa_cfg->host);
3392 if (!ioa_cfg->scan_enabled) {
3393 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3400 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
3401 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3405 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3406 if (res->del_from_ml && res->sdev) {
3409 if (!scsi_device_get(sdev)) {
3410 if (!res->add_to_ml)
3411 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3413 res->del_from_ml = 0;
3414 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3415 scsi_remove_device(sdev);
3416 scsi_device_put(sdev);
3417 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3424 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3425 if (res->add_to_ml) {
3427 target = res->target;
3430 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3431 scsi_add_device(ioa_cfg->host, bus, target, lun);
3432 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3437 ioa_cfg->scan_done = 1;
3438 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3439 kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
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 *scatterlist;
3907 /* Determine the actual number of bytes per element */
3908 bsize_elem = PAGE_SIZE * (1 << sglist->order);
3910 scatterlist = sglist->scatterlist;
3912 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3913 struct page *page = sg_page(&scatterlist[i]);
3916 memcpy(kaddr, buffer, bsize_elem);
3919 scatterlist[i].length = bsize_elem;
3927 if (len % bsize_elem) {
3928 struct page *page = sg_page(&scatterlist[i]);
3931 memcpy(kaddr, buffer, len % bsize_elem);
3934 scatterlist[i].length = len % bsize_elem;
3937 sglist->buffer_len = len;
3942 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3943 * @ipr_cmd: ipr command struct
3944 * @sglist: scatter/gather list
3946 * Builds a microcode download IOA data list (IOADL).
3949 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3950 struct ipr_sglist *sglist)
3952 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3953 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3954 struct scatterlist *scatterlist = sglist->scatterlist;
3957 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3958 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3959 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3962 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3963 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3964 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3965 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
3966 ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
3969 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3973 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3974 * @ipr_cmd: ipr command struct
3975 * @sglist: scatter/gather list
3977 * Builds a microcode download IOA data list (IOADL).
3980 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3981 struct ipr_sglist *sglist)
3983 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3984 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3985 struct scatterlist *scatterlist = sglist->scatterlist;
3988 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3989 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3990 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3993 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3995 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3996 ioadl[i].flags_and_data_len =
3997 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
3999 cpu_to_be32(sg_dma_address(&scatterlist[i]));
4002 ioadl[i-1].flags_and_data_len |=
4003 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
4007 * ipr_update_ioa_ucode - Update IOA's microcode
4008 * @ioa_cfg: ioa config struct
4009 * @sglist: scatter/gather list
4011 * Initiate an adapter reset to update the IOA's microcode
4014 * 0 on success / -EIO on failure
4016 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
4017 struct ipr_sglist *sglist)
4019 unsigned long lock_flags;
4021 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4022 while (ioa_cfg->in_reset_reload) {
4023 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4024 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4025 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4028 if (ioa_cfg->ucode_sglist) {
4029 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4030 dev_err(&ioa_cfg->pdev->dev,
4031 "Microcode download already in progress\n");
4035 sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
4036 sglist->scatterlist, sglist->num_sg,
4039 if (!sglist->num_dma_sg) {
4040 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4041 dev_err(&ioa_cfg->pdev->dev,
4042 "Failed to map microcode download buffer!\n");
4046 ioa_cfg->ucode_sglist = sglist;
4047 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
4048 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4049 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4051 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4052 ioa_cfg->ucode_sglist = NULL;
4053 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4058 * ipr_store_update_fw - Update the firmware on the adapter
4059 * @class_dev: device struct
4061 * @count: buffer size
4063 * This function will update the firmware on the adapter.
4066 * count on success / other on failure
4068 static ssize_t ipr_store_update_fw(struct device *dev,
4069 struct device_attribute *attr,
4070 const char *buf, size_t count)
4072 struct Scsi_Host *shost = class_to_shost(dev);
4073 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4074 struct ipr_ucode_image_header *image_hdr;
4075 const struct firmware *fw_entry;
4076 struct ipr_sglist *sglist;
4080 int result, dnld_size;
4082 if (!capable(CAP_SYS_ADMIN))
4085 snprintf(fname, sizeof(fname), "%s", buf);
4087 endline = strchr(fname, '\n');
4091 if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
4092 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
4096 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
4098 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
4099 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
4100 sglist = ipr_alloc_ucode_buffer(dnld_size);
4103 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
4104 release_firmware(fw_entry);
4108 result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
4111 dev_err(&ioa_cfg->pdev->dev,
4112 "Microcode buffer copy to DMA buffer failed\n");
4116 ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n");
4118 result = ipr_update_ioa_ucode(ioa_cfg, sglist);
4123 ipr_free_ucode_buffer(sglist);
4124 release_firmware(fw_entry);
4128 static struct device_attribute ipr_update_fw_attr = {
4130 .name = "update_fw",
4133 .store = ipr_store_update_fw
4137 * ipr_show_fw_type - Show the adapter's firmware type.
4138 * @dev: class device struct
4142 * number of bytes printed to buffer
4144 static ssize_t ipr_show_fw_type(struct device *dev,
4145 struct device_attribute *attr, char *buf)
4147 struct Scsi_Host *shost = class_to_shost(dev);
4148 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4149 unsigned long lock_flags = 0;
4152 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4153 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
4154 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4158 static struct device_attribute ipr_ioa_fw_type_attr = {
4163 .show = ipr_show_fw_type
4166 static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj,
4167 struct bin_attribute *bin_attr, char *buf,
4168 loff_t off, size_t count)
4170 struct device *cdev = container_of(kobj, struct device, kobj);
4171 struct Scsi_Host *shost = class_to_shost(cdev);
4172 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4173 struct ipr_hostrcb *hostrcb;
4174 unsigned long lock_flags = 0;
4177 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4178 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4179 struct ipr_hostrcb, queue);
4181 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4184 ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam,
4185 sizeof(hostrcb->hcam));
4186 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4190 static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj,
4191 struct bin_attribute *bin_attr, char *buf,
4192 loff_t off, size_t count)
4194 struct device *cdev = container_of(kobj, struct device, kobj);
4195 struct Scsi_Host *shost = class_to_shost(cdev);
4196 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4197 struct ipr_hostrcb *hostrcb;
4198 unsigned long lock_flags = 0;
4200 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4201 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4202 struct ipr_hostrcb, queue);
4204 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4208 /* Reclaim hostrcb before exit */
4209 list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
4210 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4214 static struct bin_attribute ipr_ioa_async_err_log = {
4216 .name = "async_err_log",
4217 .mode = S_IRUGO | S_IWUSR,
4220 .read = ipr_read_async_err_log,
4221 .write = ipr_next_async_err_log
4224 static struct device_attribute *ipr_ioa_attrs[] = {
4225 &ipr_fw_version_attr,
4226 &ipr_log_level_attr,
4227 &ipr_diagnostics_attr,
4228 &ipr_ioa_state_attr,
4229 &ipr_ioa_reset_attr,
4230 &ipr_update_fw_attr,
4231 &ipr_ioa_fw_type_attr,
4232 &ipr_iopoll_weight_attr,
4236 #ifdef CONFIG_SCSI_IPR_DUMP
4238 * ipr_read_dump - Dump the adapter
4239 * @filp: open sysfs file
4240 * @kobj: kobject struct
4241 * @bin_attr: bin_attribute struct
4244 * @count: buffer size
4247 * number of bytes printed to buffer
4249 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
4250 struct bin_attribute *bin_attr,
4251 char *buf, loff_t off, size_t count)
4253 struct device *cdev = container_of(kobj, struct device, kobj);
4254 struct Scsi_Host *shost = class_to_shost(cdev);
4255 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4256 struct ipr_dump *dump;
4257 unsigned long lock_flags = 0;
4262 if (!capable(CAP_SYS_ADMIN))
4265 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4266 dump = ioa_cfg->dump;
4268 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
4269 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4272 kref_get(&dump->kref);
4273 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4275 if (off > dump->driver_dump.hdr.len) {
4276 kref_put(&dump->kref, ipr_release_dump);
4280 if (off + count > dump->driver_dump.hdr.len) {
4281 count = dump->driver_dump.hdr.len - off;
4285 if (count && off < sizeof(dump->driver_dump)) {
4286 if (off + count > sizeof(dump->driver_dump))
4287 len = sizeof(dump->driver_dump) - off;
4290 src = (u8 *)&dump->driver_dump + off;
4291 memcpy(buf, src, len);
4297 off -= sizeof(dump->driver_dump);
4300 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4301 (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
4302 sizeof(struct ipr_sdt_entry));
4304 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4305 (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
4307 if (count && off < sdt_end) {
4308 if (off + count > sdt_end)
4309 len = sdt_end - off;
4312 src = (u8 *)&dump->ioa_dump + off;
4313 memcpy(buf, src, len);
4322 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
4323 len = PAGE_ALIGN(off) - off;
4326 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
4327 src += off & ~PAGE_MASK;
4328 memcpy(buf, src, len);
4334 kref_put(&dump->kref, ipr_release_dump);
4339 * ipr_alloc_dump - Prepare for adapter dump
4340 * @ioa_cfg: ioa config struct
4343 * 0 on success / other on failure
4345 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
4347 struct ipr_dump *dump;
4349 unsigned long lock_flags = 0;
4351 dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
4354 ipr_err("Dump memory allocation failed\n");
4359 ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES,
4362 ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES,
4366 ipr_err("Dump memory allocation failed\n");
4371 dump->ioa_dump.ioa_data = ioa_data;
4373 kref_init(&dump->kref);
4374 dump->ioa_cfg = ioa_cfg;
4376 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4378 if (INACTIVE != ioa_cfg->sdt_state) {
4379 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4380 vfree(dump->ioa_dump.ioa_data);
4385 ioa_cfg->dump = dump;
4386 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
4387 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
4388 ioa_cfg->dump_taken = 1;
4389 schedule_work(&ioa_cfg->work_q);
4391 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4397 * ipr_free_dump - Free adapter dump memory
4398 * @ioa_cfg: ioa config struct
4401 * 0 on success / other on failure
4403 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4405 struct ipr_dump *dump;
4406 unsigned long lock_flags = 0;
4410 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4411 dump = ioa_cfg->dump;
4413 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4417 ioa_cfg->dump = NULL;
4418 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4420 kref_put(&dump->kref, ipr_release_dump);
4427 * ipr_write_dump - Setup dump state of adapter
4428 * @filp: open sysfs file
4429 * @kobj: kobject struct
4430 * @bin_attr: bin_attribute struct
4433 * @count: buffer size
4436 * number of bytes printed to buffer
4438 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4439 struct bin_attribute *bin_attr,
4440 char *buf, loff_t off, size_t count)
4442 struct device *cdev = container_of(kobj, struct device, kobj);
4443 struct Scsi_Host *shost = class_to_shost(cdev);
4444 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4447 if (!capable(CAP_SYS_ADMIN))
4451 rc = ipr_alloc_dump(ioa_cfg);
4452 else if (buf[0] == '0')
4453 rc = ipr_free_dump(ioa_cfg);
4463 static struct bin_attribute ipr_dump_attr = {
4466 .mode = S_IRUSR | S_IWUSR,
4469 .read = ipr_read_dump,
4470 .write = ipr_write_dump
4473 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4477 * ipr_change_queue_depth - Change the device's queue depth
4478 * @sdev: scsi device struct
4479 * @qdepth: depth to set
4480 * @reason: calling context
4485 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
4487 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4488 struct ipr_resource_entry *res;
4489 unsigned long lock_flags = 0;
4491 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4492 res = (struct ipr_resource_entry *)sdev->hostdata;
4494 if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4495 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4496 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4498 scsi_change_queue_depth(sdev, qdepth);
4499 return sdev->queue_depth;
4503 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4504 * @dev: device struct
4505 * @attr: device attribute structure
4509 * number of bytes printed to buffer
4511 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4513 struct scsi_device *sdev = to_scsi_device(dev);
4514 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4515 struct ipr_resource_entry *res;
4516 unsigned long lock_flags = 0;
4517 ssize_t len = -ENXIO;
4519 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4520 res = (struct ipr_resource_entry *)sdev->hostdata;
4522 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4523 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4527 static struct device_attribute ipr_adapter_handle_attr = {
4529 .name = "adapter_handle",
4532 .show = ipr_show_adapter_handle
4536 * ipr_show_resource_path - Show the resource path or the resource address for
4538 * @dev: device struct
4539 * @attr: device attribute structure
4543 * number of bytes printed to buffer
4545 static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4547 struct scsi_device *sdev = to_scsi_device(dev);
4548 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4549 struct ipr_resource_entry *res;
4550 unsigned long lock_flags = 0;
4551 ssize_t len = -ENXIO;
4552 char buffer[IPR_MAX_RES_PATH_LENGTH];
4554 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4555 res = (struct ipr_resource_entry *)sdev->hostdata;
4556 if (res && ioa_cfg->sis64)
4557 len = snprintf(buf, PAGE_SIZE, "%s\n",
4558 __ipr_format_res_path(res->res_path, buffer,
4561 len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4562 res->bus, res->target, res->lun);
4564 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4568 static struct device_attribute ipr_resource_path_attr = {
4570 .name = "resource_path",
4573 .show = ipr_show_resource_path
4577 * ipr_show_device_id - Show the device_id for this device.
4578 * @dev: device struct
4579 * @attr: device attribute structure
4583 * number of bytes printed to buffer
4585 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4587 struct scsi_device *sdev = to_scsi_device(dev);
4588 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4589 struct ipr_resource_entry *res;
4590 unsigned long lock_flags = 0;
4591 ssize_t len = -ENXIO;
4593 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4594 res = (struct ipr_resource_entry *)sdev->hostdata;
4595 if (res && ioa_cfg->sis64)
4596 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id));
4598 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4600 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4604 static struct device_attribute ipr_device_id_attr = {
4606 .name = "device_id",
4609 .show = ipr_show_device_id
4613 * ipr_show_resource_type - Show the resource type for this device.
4614 * @dev: device struct
4615 * @attr: device attribute structure
4619 * number of bytes printed to buffer
4621 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4623 struct scsi_device *sdev = to_scsi_device(dev);
4624 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4625 struct ipr_resource_entry *res;
4626 unsigned long lock_flags = 0;
4627 ssize_t len = -ENXIO;
4629 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4630 res = (struct ipr_resource_entry *)sdev->hostdata;
4633 len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4635 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4639 static struct device_attribute ipr_resource_type_attr = {
4641 .name = "resource_type",
4644 .show = ipr_show_resource_type
4648 * ipr_show_raw_mode - Show the adapter's raw mode
4649 * @dev: class device struct
4653 * number of bytes printed to buffer
4655 static ssize_t ipr_show_raw_mode(struct device *dev,
4656 struct device_attribute *attr, char *buf)
4658 struct scsi_device *sdev = to_scsi_device(dev);
4659 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4660 struct ipr_resource_entry *res;
4661 unsigned long lock_flags = 0;
4664 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4665 res = (struct ipr_resource_entry *)sdev->hostdata;
4667 len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode);
4670 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4675 * ipr_store_raw_mode - Change the adapter's raw mode
4676 * @dev: class device struct
4680 * number of bytes printed to buffer
4682 static ssize_t ipr_store_raw_mode(struct device *dev,
4683 struct device_attribute *attr,
4684 const char *buf, size_t count)
4686 struct scsi_device *sdev = to_scsi_device(dev);
4687 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4688 struct ipr_resource_entry *res;
4689 unsigned long lock_flags = 0;
4692 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4693 res = (struct ipr_resource_entry *)sdev->hostdata;
4695 if (ipr_is_af_dasd_device(res)) {
4696 res->raw_mode = simple_strtoul(buf, NULL, 10);
4699 sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n",
4700 res->raw_mode ? "enabled" : "disabled");
4705 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4709 static struct device_attribute ipr_raw_mode_attr = {
4712 .mode = S_IRUGO | S_IWUSR,
4714 .show = ipr_show_raw_mode,
4715 .store = ipr_store_raw_mode
4718 static struct device_attribute *ipr_dev_attrs[] = {
4719 &ipr_adapter_handle_attr,
4720 &ipr_resource_path_attr,
4721 &ipr_device_id_attr,
4722 &ipr_resource_type_attr,
4728 * ipr_biosparam - Return the HSC mapping
4729 * @sdev: scsi device struct
4730 * @block_device: block device pointer
4731 * @capacity: capacity of the device
4732 * @parm: Array containing returned HSC values.
4734 * This function generates the HSC parms that fdisk uses.
4735 * We want to make sure we return something that places partitions
4736 * on 4k boundaries for best performance with the IOA.
4741 static int ipr_biosparam(struct scsi_device *sdev,
4742 struct block_device *block_device,
4743 sector_t capacity, int *parm)
4751 cylinders = capacity;
4752 sector_div(cylinders, (128 * 32));
4757 parm[2] = cylinders;
4763 * ipr_find_starget - Find target based on bus/target.
4764 * @starget: scsi target struct
4767 * resource entry pointer if found / NULL if not found
4769 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4771 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4772 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4773 struct ipr_resource_entry *res;
4775 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4776 if ((res->bus == starget->channel) &&
4777 (res->target == starget->id)) {
4785 static struct ata_port_info sata_port_info;
4788 * ipr_target_alloc - Prepare for commands to a SCSI target
4789 * @starget: scsi target struct
4791 * If the device is a SATA device, this function allocates an
4792 * ATA port with libata, else it does nothing.
4795 * 0 on success / non-0 on failure
4797 static int ipr_target_alloc(struct scsi_target *starget)
4799 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4800 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4801 struct ipr_sata_port *sata_port;
4802 struct ata_port *ap;
4803 struct ipr_resource_entry *res;
4804 unsigned long lock_flags;
4806 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4807 res = ipr_find_starget(starget);
4808 starget->hostdata = NULL;
4810 if (res && ipr_is_gata(res)) {
4811 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4812 sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4816 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4818 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4819 sata_port->ioa_cfg = ioa_cfg;
4821 sata_port->res = res;
4823 res->sata_port = sata_port;
4824 ap->private_data = sata_port;
4825 starget->hostdata = sata_port;
4831 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4837 * ipr_target_destroy - Destroy a SCSI target
4838 * @starget: scsi target struct
4840 * If the device was a SATA device, this function frees the libata
4841 * ATA port, else it does nothing.
4844 static void ipr_target_destroy(struct scsi_target *starget)
4846 struct ipr_sata_port *sata_port = starget->hostdata;
4847 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4848 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4850 if (ioa_cfg->sis64) {
4851 if (!ipr_find_starget(starget)) {
4852 if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4853 clear_bit(starget->id, ioa_cfg->array_ids);
4854 else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4855 clear_bit(starget->id, ioa_cfg->vset_ids);
4856 else if (starget->channel == 0)
4857 clear_bit(starget->id, ioa_cfg->target_ids);
4862 starget->hostdata = NULL;
4863 ata_sas_port_destroy(sata_port->ap);
4869 * ipr_find_sdev - Find device based on bus/target/lun.
4870 * @sdev: scsi device struct
4873 * resource entry pointer if found / NULL if not found
4875 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4877 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4878 struct ipr_resource_entry *res;
4880 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4881 if ((res->bus == sdev->channel) &&
4882 (res->target == sdev->id) &&
4883 (res->lun == sdev->lun))
4891 * ipr_slave_destroy - Unconfigure a SCSI device
4892 * @sdev: scsi device struct
4897 static void ipr_slave_destroy(struct scsi_device *sdev)
4899 struct ipr_resource_entry *res;
4900 struct ipr_ioa_cfg *ioa_cfg;
4901 unsigned long lock_flags = 0;
4903 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4905 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4906 res = (struct ipr_resource_entry *) sdev->hostdata;
4909 res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4910 sdev->hostdata = NULL;
4912 res->sata_port = NULL;
4914 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4918 * ipr_slave_configure - Configure a SCSI device
4919 * @sdev: scsi device struct
4921 * This function configures the specified scsi device.
4926 static int ipr_slave_configure(struct scsi_device *sdev)
4928 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4929 struct ipr_resource_entry *res;
4930 struct ata_port *ap = NULL;
4931 unsigned long lock_flags = 0;
4932 char buffer[IPR_MAX_RES_PATH_LENGTH];
4934 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4935 res = sdev->hostdata;
4937 if (ipr_is_af_dasd_device(res))
4938 sdev->type = TYPE_RAID;
4939 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4940 sdev->scsi_level = 4;
4941 sdev->no_uld_attach = 1;
4943 if (ipr_is_vset_device(res)) {
4944 sdev->scsi_level = SCSI_SPC_3;
4945 sdev->no_report_opcodes = 1;
4946 blk_queue_rq_timeout(sdev->request_queue,
4947 IPR_VSET_RW_TIMEOUT);
4948 blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4950 if (ipr_is_gata(res) && res->sata_port)
4951 ap = res->sata_port->ap;
4952 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4955 scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
4956 ata_sas_slave_configure(sdev, ap);
4960 sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4961 ipr_format_res_path(ioa_cfg,
4962 res->res_path, buffer, sizeof(buffer)));
4965 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4970 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4971 * @sdev: scsi device struct
4973 * This function initializes an ATA port so that future commands
4974 * sent through queuecommand will work.
4979 static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4981 struct ipr_sata_port *sata_port = NULL;
4985 if (sdev->sdev_target)
4986 sata_port = sdev->sdev_target->hostdata;
4988 rc = ata_sas_port_init(sata_port->ap);
4990 rc = ata_sas_sync_probe(sata_port->ap);
4994 ipr_slave_destroy(sdev);
5001 * ipr_slave_alloc - Prepare for commands to a device.
5002 * @sdev: scsi device struct
5004 * This function saves a pointer to the resource entry
5005 * in the scsi device struct if the device exists. We
5006 * can then use this pointer in ipr_queuecommand when
5007 * handling new commands.
5010 * 0 on success / -ENXIO if device does not exist
5012 static int ipr_slave_alloc(struct scsi_device *sdev)
5014 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
5015 struct ipr_resource_entry *res;
5016 unsigned long lock_flags;
5019 sdev->hostdata = NULL;
5021 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5023 res = ipr_find_sdev(sdev);
5028 sdev->hostdata = res;
5029 if (!ipr_is_naca_model(res))
5030 res->needs_sync_complete = 1;
5032 if (ipr_is_gata(res)) {
5033 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5034 return ipr_ata_slave_alloc(sdev);
5038 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5044 * ipr_match_lun - Match function for specified LUN
5045 * @ipr_cmd: ipr command struct
5046 * @device: device to match (sdev)
5049 * 1 if command matches sdev / 0 if command does not match sdev
5051 static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device)
5053 if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device)
5059 * ipr_cmnd_is_free - Check if a command is free or not
5060 * @ipr_cmd ipr command struct
5065 static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd)
5067 struct ipr_cmnd *loop_cmd;
5069 list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) {
5070 if (loop_cmd == ipr_cmd)
5078 * ipr_match_res - Match function for specified resource entry
5079 * @ipr_cmd: ipr command struct
5080 * @resource: resource entry to match
5083 * 1 if command matches sdev / 0 if command does not match sdev
5085 static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource)
5087 struct ipr_resource_entry *res = resource;
5089 if (res && ipr_cmd->ioarcb.res_handle == res->res_handle)
5095 * ipr_wait_for_ops - Wait for matching commands to complete
5096 * @ipr_cmd: ipr command struct
5097 * @device: device to match (sdev)
5098 * @match: match function to use
5103 static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device,
5104 int (*match)(struct ipr_cmnd *, void *))
5106 struct ipr_cmnd *ipr_cmd;
5108 unsigned long flags;
5109 struct ipr_hrr_queue *hrrq;
5110 signed long timeout = IPR_ABORT_TASK_TIMEOUT;
5111 DECLARE_COMPLETION_ONSTACK(comp);
5117 for_each_hrrq(hrrq, ioa_cfg) {
5118 spin_lock_irqsave(hrrq->lock, flags);
5119 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5120 ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5121 if (!ipr_cmnd_is_free(ipr_cmd)) {
5122 if (match(ipr_cmd, device)) {
5123 ipr_cmd->eh_comp = ∁
5128 spin_unlock_irqrestore(hrrq->lock, flags);
5132 timeout = wait_for_completion_timeout(&comp, timeout);
5137 for_each_hrrq(hrrq, ioa_cfg) {
5138 spin_lock_irqsave(hrrq->lock, flags);
5139 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5140 ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5141 if (!ipr_cmnd_is_free(ipr_cmd)) {
5142 if (match(ipr_cmd, device)) {
5143 ipr_cmd->eh_comp = NULL;
5148 spin_unlock_irqrestore(hrrq->lock, flags);
5152 dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n");
5154 return wait ? FAILED : SUCCESS;
5163 static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
5165 struct ipr_ioa_cfg *ioa_cfg;
5166 unsigned long lock_flags = 0;
5170 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5171 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5173 if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5174 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5175 dev_err(&ioa_cfg->pdev->dev,
5176 "Adapter being reset as a result of error recovery.\n");
5178 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5179 ioa_cfg->sdt_state = GET_DUMP;
5182 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5183 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5184 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5186 /* If we got hit with a host reset while we were already resetting
5187 the adapter for some reason, and the reset failed. */
5188 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5193 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5199 * ipr_device_reset - Reset the device
5200 * @ioa_cfg: ioa config struct
5201 * @res: resource entry struct
5203 * This function issues a device reset to the affected device.
5204 * If the device is a SCSI device, a LUN reset will be sent
5205 * to the device first. If that does not work, a target reset
5206 * will be sent. If the device is a SATA device, a PHY reset will
5210 * 0 on success / non-zero on failure
5212 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
5213 struct ipr_resource_entry *res)
5215 struct ipr_cmnd *ipr_cmd;
5216 struct ipr_ioarcb *ioarcb;
5217 struct ipr_cmd_pkt *cmd_pkt;
5218 struct ipr_ioarcb_ata_regs *regs;
5222 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5223 ioarcb = &ipr_cmd->ioarcb;
5224 cmd_pkt = &ioarcb->cmd_pkt;
5226 if (ipr_cmd->ioa_cfg->sis64) {
5227 regs = &ipr_cmd->i.ata_ioadl.regs;
5228 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
5230 regs = &ioarcb->u.add_data.u.regs;
5232 ioarcb->res_handle = res->res_handle;
5233 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5234 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5235 if (ipr_is_gata(res)) {
5236 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
5237 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
5238 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
5241 ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5242 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5243 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5244 if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
5245 if (ipr_cmd->ioa_cfg->sis64)
5246 memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
5247 sizeof(struct ipr_ioasa_gata));
5249 memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
5250 sizeof(struct ipr_ioasa_gata));
5254 return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
5258 * ipr_sata_reset - Reset the SATA port
5259 * @link: SATA link to reset
5260 * @classes: class of the attached device
5262 * This function issues a SATA phy reset to the affected ATA link.
5265 * 0 on success / non-zero on failure
5267 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
5268 unsigned long deadline)
5270 struct ipr_sata_port *sata_port = link->ap->private_data;
5271 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
5272 struct ipr_resource_entry *res;
5273 unsigned long lock_flags = 0;
5274 int rc = -ENXIO, ret;
5277 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5278 while (ioa_cfg->in_reset_reload) {
5279 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5280 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5281 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5284 res = sata_port->res;
5286 rc = ipr_device_reset(ioa_cfg, res);
5287 *classes = res->ata_class;
5288 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5290 ret = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5291 if (ret != SUCCESS) {
5292 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5293 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5294 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5296 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5299 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5306 * ipr_eh_dev_reset - Reset the device
5307 * @scsi_cmd: scsi command struct
5309 * This function issues a device reset to the affected device.
5310 * A LUN reset will be sent to the device first. If that does
5311 * not work, a target reset will be sent.
5316 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
5318 struct ipr_cmnd *ipr_cmd;
5319 struct ipr_ioa_cfg *ioa_cfg;
5320 struct ipr_resource_entry *res;
5321 struct ata_port *ap;
5323 struct ipr_hrr_queue *hrrq;
5326 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5327 res = scsi_cmd->device->hostdata;
5330 * If we are currently going through reset/reload, return failed. This will force the
5331 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
5334 if (ioa_cfg->in_reset_reload)
5336 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5339 for_each_hrrq(hrrq, ioa_cfg) {
5340 spin_lock(&hrrq->_lock);
5341 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5342 ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5344 if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
5347 if (ipr_cmnd_is_free(ipr_cmd))
5350 ipr_cmd->done = ipr_sata_eh_done;
5351 if (!(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
5352 ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
5353 ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
5357 spin_unlock(&hrrq->_lock);
5359 res->resetting_device = 1;
5360 scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
5362 if (ipr_is_gata(res) && res->sata_port) {
5363 ap = res->sata_port->ap;
5364 spin_unlock_irq(scsi_cmd->device->host->host_lock);
5365 ata_std_error_handler(ap);
5366 spin_lock_irq(scsi_cmd->device->host->host_lock);
5368 rc = ipr_device_reset(ioa_cfg, res);
5369 res->resetting_device = 0;
5370 res->reset_occurred = 1;
5373 return rc ? FAILED : SUCCESS;
5376 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
5379 struct ipr_ioa_cfg *ioa_cfg;
5380 struct ipr_resource_entry *res;
5382 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5383 res = cmd->device->hostdata;
5388 spin_lock_irq(cmd->device->host->host_lock);
5389 rc = __ipr_eh_dev_reset(cmd);
5390 spin_unlock_irq(cmd->device->host->host_lock);
5392 if (rc == SUCCESS) {
5393 if (ipr_is_gata(res) && res->sata_port)
5394 rc = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5396 rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun);
5403 * ipr_bus_reset_done - Op done function for bus reset.
5404 * @ipr_cmd: ipr command struct
5406 * This function is the op done function for a bus reset
5411 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
5413 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5414 struct ipr_resource_entry *res;
5417 if (!ioa_cfg->sis64)
5418 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
5419 if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
5420 scsi_report_bus_reset(ioa_cfg->host, res->bus);
5426 * If abort has not completed, indicate the reset has, else call the
5427 * abort's done function to wake the sleeping eh thread
5429 if (ipr_cmd->sibling->sibling)
5430 ipr_cmd->sibling->sibling = NULL;
5432 ipr_cmd->sibling->done(ipr_cmd->sibling);
5434 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5439 * ipr_abort_timeout - An abort task has timed out
5440 * @ipr_cmd: ipr command struct
5442 * This function handles when an abort task times out. If this
5443 * happens we issue a bus reset since we have resources tied
5444 * up that must be freed before returning to the midlayer.
5449 static void ipr_abort_timeout(struct timer_list *t)
5451 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
5452 struct ipr_cmnd *reset_cmd;
5453 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5454 struct ipr_cmd_pkt *cmd_pkt;
5455 unsigned long lock_flags = 0;
5458 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5459 if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
5460 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5464 sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
5465 reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5466 ipr_cmd->sibling = reset_cmd;
5467 reset_cmd->sibling = ipr_cmd;
5468 reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
5469 cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
5470 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5471 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5472 cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
5474 ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5475 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5480 * ipr_cancel_op - Cancel specified op
5481 * @scsi_cmd: scsi command struct
5483 * This function cancels specified op.
5488 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
5490 struct ipr_cmnd *ipr_cmd;
5491 struct ipr_ioa_cfg *ioa_cfg;
5492 struct ipr_resource_entry *res;
5493 struct ipr_cmd_pkt *cmd_pkt;
5495 int i, op_found = 0;
5496 struct ipr_hrr_queue *hrrq;
5499 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5500 res = scsi_cmd->device->hostdata;
5502 /* If we are currently going through reset/reload, return failed.
5503 * This will force the mid-layer to call ipr_eh_host_reset,
5504 * which will then go to sleep and wait for the reset to complete
5506 if (ioa_cfg->in_reset_reload ||
5507 ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5513 * If we are aborting a timed out op, chances are that the timeout was caused
5514 * by a still not detected EEH error. In such cases, reading a register will
5515 * trigger the EEH recovery infrastructure.
5517 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5519 if (!ipr_is_gscsi(res))
5522 for_each_hrrq(hrrq, ioa_cfg) {
5523 spin_lock(&hrrq->_lock);
5524 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5525 if (ioa_cfg->ipr_cmnd_list[i]->scsi_cmd == scsi_cmd) {
5526 if (!ipr_cmnd_is_free(ioa_cfg->ipr_cmnd_list[i])) {
5532 spin_unlock(&hrrq->_lock);
5538 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5539 ipr_cmd->ioarcb.res_handle = res->res_handle;
5540 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5541 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5542 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
5543 ipr_cmd->u.sdev = scsi_cmd->device;
5545 scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
5547 ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
5548 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5551 * If the abort task timed out and we sent a bus reset, we will get
5552 * one the following responses to the abort
5554 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
5559 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5560 if (!ipr_is_naca_model(res))
5561 res->needs_sync_complete = 1;
5564 return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
5568 * ipr_eh_abort - Abort a single op
5569 * @scsi_cmd: scsi command struct
5572 * 0 if scan in progress / 1 if scan is complete
5574 static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time)
5576 unsigned long lock_flags;
5577 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
5580 spin_lock_irqsave(shost->host_lock, lock_flags);
5581 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done)
5583 if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2))
5585 spin_unlock_irqrestore(shost->host_lock, lock_flags);
5590 * ipr_eh_host_reset - Reset the host adapter
5591 * @scsi_cmd: scsi command struct
5596 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
5598 unsigned long flags;
5600 struct ipr_ioa_cfg *ioa_cfg;
5604 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5606 spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
5607 rc = ipr_cancel_op(scsi_cmd);
5608 spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
5611 rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun);
5617 * ipr_handle_other_interrupt - Handle "other" interrupts
5618 * @ioa_cfg: ioa config struct
5619 * @int_reg: interrupt register
5622 * IRQ_NONE / IRQ_HANDLED
5624 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5627 irqreturn_t rc = IRQ_HANDLED;
5630 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5631 int_reg &= ~int_mask_reg;
5633 /* If an interrupt on the adapter did not occur, ignore it.
5634 * Or in the case of SIS 64, check for a stage change interrupt.
5636 if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
5637 if (ioa_cfg->sis64) {
5638 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5639 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5640 if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
5642 /* clear stage change */
5643 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
5644 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5645 list_del(&ioa_cfg->reset_cmd->queue);
5646 del_timer(&ioa_cfg->reset_cmd->timer);
5647 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5655 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5656 /* Mask the interrupt */
5657 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
5658 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5660 list_del(&ioa_cfg->reset_cmd->queue);
5661 del_timer(&ioa_cfg->reset_cmd->timer);
5662 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5663 } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
5664 if (ioa_cfg->clear_isr) {
5665 if (ipr_debug && printk_ratelimit())
5666 dev_err(&ioa_cfg->pdev->dev,
5667 "Spurious interrupt detected. 0x%08X\n", int_reg);
5668 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
5669 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5673 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
5674 ioa_cfg->ioa_unit_checked = 1;
5675 else if (int_reg & IPR_PCII_NO_HOST_RRQ)
5676 dev_err(&ioa_cfg->pdev->dev,
5677 "No Host RRQ. 0x%08X\n", int_reg);
5679 dev_err(&ioa_cfg->pdev->dev,
5680 "Permanent IOA failure. 0x%08X\n", int_reg);
5682 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5683 ioa_cfg->sdt_state = GET_DUMP;
5685 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5686 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5693 * ipr_isr_eh - Interrupt service routine error handler
5694 * @ioa_cfg: ioa config struct
5695 * @msg: message to log
5700 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number)
5702 ioa_cfg->errors_logged++;
5703 dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number);
5705 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5706 ioa_cfg->sdt_state = GET_DUMP;
5708 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5711 static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget,
5712 struct list_head *doneq)
5716 struct ipr_cmnd *ipr_cmd;
5717 struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg;
5720 /* If interrupts are disabled, ignore the interrupt */
5721 if (!hrr_queue->allow_interrupts)
5724 while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5725 hrr_queue->toggle_bit) {
5727 cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) &
5728 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >>
5729 IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
5731 if (unlikely(cmd_index > hrr_queue->max_cmd_id ||
5732 cmd_index < hrr_queue->min_cmd_id)) {
5734 "Invalid response handle from IOA: ",
5739 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
5740 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5742 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
5744 list_move_tail(&ipr_cmd->queue, doneq);
5746 if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) {
5747 hrr_queue->hrrq_curr++;
5749 hrr_queue->hrrq_curr = hrr_queue->hrrq_start;
5750 hrr_queue->toggle_bit ^= 1u;
5753 if (budget > 0 && num_hrrq >= budget)
5760 static int ipr_iopoll(struct irq_poll *iop, int budget)
5762 struct ipr_ioa_cfg *ioa_cfg;
5763 struct ipr_hrr_queue *hrrq;
5764 struct ipr_cmnd *ipr_cmd, *temp;
5765 unsigned long hrrq_flags;
5769 hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
5770 ioa_cfg = hrrq->ioa_cfg;
5772 spin_lock_irqsave(hrrq->lock, hrrq_flags);
5773 completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
5775 if (completed_ops < budget)
5776 irq_poll_complete(iop);
5777 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5779 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5780 list_del(&ipr_cmd->queue);
5781 del_timer(&ipr_cmd->timer);
5782 ipr_cmd->fast_done(ipr_cmd);
5785 return completed_ops;
5789 * ipr_isr - Interrupt service routine
5791 * @devp: pointer to ioa config struct
5794 * IRQ_NONE / IRQ_HANDLED
5796 static irqreturn_t ipr_isr(int irq, void *devp)
5798 struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5799 struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5800 unsigned long hrrq_flags = 0;
5804 struct ipr_cmnd *ipr_cmd, *temp;
5805 irqreturn_t rc = IRQ_NONE;
5808 spin_lock_irqsave(hrrq->lock, hrrq_flags);
5809 /* If interrupts are disabled, ignore the interrupt */
5810 if (!hrrq->allow_interrupts) {
5811 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5816 if (ipr_process_hrrq(hrrq, -1, &doneq)) {
5819 if (!ioa_cfg->clear_isr)
5822 /* Clear the PCI interrupt */
5825 writel(IPR_PCII_HRRQ_UPDATED,
5826 ioa_cfg->regs.clr_interrupt_reg32);
5827 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5828 } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
5829 num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
5831 } else if (rc == IRQ_NONE && irq_none == 0) {
5832 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5834 } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
5835 int_reg & IPR_PCII_HRRQ_UPDATED) {
5837 "Error clearing HRRQ: ", num_hrrq);
5844 if (unlikely(rc == IRQ_NONE))
5845 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
5847 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5848 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5849 list_del(&ipr_cmd->queue);
5850 del_timer(&ipr_cmd->timer);
5851 ipr_cmd->fast_done(ipr_cmd);
5857 * ipr_isr_mhrrq - Interrupt service routine
5859 * @devp: pointer to ioa config struct
5862 * IRQ_NONE / IRQ_HANDLED
5864 static irqreturn_t ipr_isr_mhrrq(int irq, void *devp)
5866 struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5867 struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5868 unsigned long hrrq_flags = 0;
5869 struct ipr_cmnd *ipr_cmd, *temp;
5870 irqreturn_t rc = IRQ_NONE;
5873 spin_lock_irqsave(hrrq->lock, hrrq_flags);
5875 /* If interrupts are disabled, ignore the interrupt */
5876 if (!hrrq->allow_interrupts) {
5877 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5881 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
5882 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5884 irq_poll_sched(&hrrq->iopoll);
5885 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5889 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5892 if (ipr_process_hrrq(hrrq, -1, &doneq))
5896 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5898 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5899 list_del(&ipr_cmd->queue);
5900 del_timer(&ipr_cmd->timer);
5901 ipr_cmd->fast_done(ipr_cmd);
5907 * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5908 * @ioa_cfg: ioa config struct
5909 * @ipr_cmd: ipr command struct
5912 * 0 on success / -1 on failure
5914 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
5915 struct ipr_cmnd *ipr_cmd)
5918 struct scatterlist *sg;
5920 u32 ioadl_flags = 0;
5921 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5922 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5923 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
5925 length = scsi_bufflen(scsi_cmd);
5929 nseg = scsi_dma_map(scsi_cmd);
5931 if (printk_ratelimit())
5932 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5936 ipr_cmd->dma_use_sg = nseg;
5938 ioarcb->data_transfer_length = cpu_to_be32(length);
5940 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
5942 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5943 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5944 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5945 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
5946 ioadl_flags = IPR_IOADL_FLAGS_READ;
5948 scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
5949 ioadl64[i].flags = cpu_to_be32(ioadl_flags);
5950 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
5951 ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
5954 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5959 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5960 * @ioa_cfg: ioa config struct
5961 * @ipr_cmd: ipr command struct
5964 * 0 on success / -1 on failure
5966 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
5967 struct ipr_cmnd *ipr_cmd)
5970 struct scatterlist *sg;
5972 u32 ioadl_flags = 0;
5973 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5974 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5975 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
5977 length = scsi_bufflen(scsi_cmd);
5981 nseg = scsi_dma_map(scsi_cmd);
5983 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5987 ipr_cmd->dma_use_sg = nseg;
5989 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5990 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5991 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5992 ioarcb->data_transfer_length = cpu_to_be32(length);
5994 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
5995 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
5996 ioadl_flags = IPR_IOADL_FLAGS_READ;
5997 ioarcb->read_data_transfer_length = cpu_to_be32(length);
5998 ioarcb->read_ioadl_len =
5999 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6002 if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
6003 ioadl = ioarcb->u.add_data.u.ioadl;
6004 ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
6005 offsetof(struct ipr_ioarcb, u.add_data));
6006 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6009 scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
6010 ioadl[i].flags_and_data_len =
6011 cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6012 ioadl[i].address = cpu_to_be32(sg_dma_address(sg));
6015 ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6020 * __ipr_erp_done - Process completion of ERP for a device
6021 * @ipr_cmd: ipr command struct
6023 * This function copies the sense buffer into the scsi_cmd
6024 * struct and pushes the scsi_done function.
6029 static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6031 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6032 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6033 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6035 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6036 scsi_cmd->result |= (DID_ERROR << 16);
6037 scmd_printk(KERN_ERR, scsi_cmd,
6038 "Request Sense failed with IOASC: 0x%08X\n", ioasc);
6040 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
6041 SCSI_SENSE_BUFFERSIZE);
6045 if (!ipr_is_naca_model(res))
6046 res->needs_sync_complete = 1;
6049 scsi_dma_unmap(ipr_cmd->scsi_cmd);
6050 scsi_cmd->scsi_done(scsi_cmd);
6051 if (ipr_cmd->eh_comp)
6052 complete(ipr_cmd->eh_comp);
6053 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6057 * ipr_erp_done - Process completion of ERP for a device
6058 * @ipr_cmd: ipr command struct
6060 * This function copies the sense buffer into the scsi_cmd
6061 * struct and pushes the scsi_done function.
6066 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6068 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6069 unsigned long hrrq_flags;
6071 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6072 __ipr_erp_done(ipr_cmd);
6073 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6077 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
6078 * @ipr_cmd: ipr command struct
6083 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
6085 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6086 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6087 dma_addr_t dma_addr = ipr_cmd->dma_addr;
6089 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
6090 ioarcb->data_transfer_length = 0;
6091 ioarcb->read_data_transfer_length = 0;
6092 ioarcb->ioadl_len = 0;
6093 ioarcb->read_ioadl_len = 0;
6094 ioasa->hdr.ioasc = 0;
6095 ioasa->hdr.residual_data_len = 0;
6097 if (ipr_cmd->ioa_cfg->sis64)
6098 ioarcb->u.sis64_addr_data.data_ioadl_addr =
6099 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
6101 ioarcb->write_ioadl_addr =
6102 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
6103 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6108 * __ipr_erp_request_sense - Send request sense to a device
6109 * @ipr_cmd: ipr command struct
6111 * This function sends a request sense to a device as a result
6112 * of a check condition.
6117 static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6119 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6120 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6122 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6123 __ipr_erp_done(ipr_cmd);
6127 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6129 cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
6130 cmd_pkt->cdb[0] = REQUEST_SENSE;
6131 cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
6132 cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
6133 cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6134 cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
6136 ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
6137 SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
6139 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
6140 IPR_REQUEST_SENSE_TIMEOUT * 2);
6144 * ipr_erp_request_sense - Send request sense to a device
6145 * @ipr_cmd: ipr command struct
6147 * This function sends a request sense to a device as a result
6148 * of a check condition.
6153 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6155 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6156 unsigned long hrrq_flags;
6158 spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6159 __ipr_erp_request_sense(ipr_cmd);
6160 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6164 * ipr_erp_cancel_all - Send cancel all to a device
6165 * @ipr_cmd: ipr command struct
6167 * This function sends a cancel all to a device to clear the
6168 * queue. If we are running TCQ on the device, QERR is set to 1,
6169 * which means all outstanding ops have been dropped on the floor.
6170 * Cancel all will return them to us.
6175 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
6177 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6178 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6179 struct ipr_cmd_pkt *cmd_pkt;
6183 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6185 if (!scsi_cmd->device->simple_tags) {
6186 __ipr_erp_request_sense(ipr_cmd);
6190 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6191 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
6192 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
6194 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
6195 IPR_CANCEL_ALL_TIMEOUT);
6199 * ipr_dump_ioasa - Dump contents of IOASA
6200 * @ioa_cfg: ioa config struct
6201 * @ipr_cmd: ipr command struct
6202 * @res: resource entry struct
6204 * This function is invoked by the interrupt handler when ops
6205 * fail. It will log the IOASA if appropriate. Only called
6211 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
6212 struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
6216 u32 ioasc, fd_ioasc;
6217 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6218 __be32 *ioasa_data = (__be32 *)ioasa;
6221 ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
6222 fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
6227 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
6230 if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
6231 error_index = ipr_get_error(fd_ioasc);
6233 error_index = ipr_get_error(ioasc);
6235 if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
6236 /* Don't log an error if the IOA already logged one */
6237 if (ioasa->hdr.ilid != 0)
6240 if (!ipr_is_gscsi(res))
6243 if (ipr_error_table[error_index].log_ioasa == 0)
6247 ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
6249 data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
6250 if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
6251 data_len = sizeof(struct ipr_ioasa64);
6252 else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
6253 data_len = sizeof(struct ipr_ioasa);
6255 ipr_err("IOASA Dump:\n");
6257 for (i = 0; i < data_len / 4; i += 4) {
6258 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
6259 be32_to_cpu(ioasa_data[i]),
6260 be32_to_cpu(ioasa_data[i+1]),
6261 be32_to_cpu(ioasa_data[i+2]),
6262 be32_to_cpu(ioasa_data[i+3]));
6267 * ipr_gen_sense - Generate SCSI sense data from an IOASA
6269 * @sense_buf: sense data buffer
6274 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
6277 u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
6278 struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
6279 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6280 u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
6282 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
6284 if (ioasc >= IPR_FIRST_DRIVER_IOASC)
6287 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
6289 if (ipr_is_vset_device(res) &&
6290 ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
6291 ioasa->u.vset.failing_lba_hi != 0) {
6292 sense_buf[0] = 0x72;
6293 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
6294 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
6295 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
6299 sense_buf[9] = 0x0A;
6300 sense_buf[10] = 0x80;
6302 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
6304 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
6305 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
6306 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
6307 sense_buf[15] = failing_lba & 0x000000ff;
6309 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6311 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
6312 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
6313 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
6314 sense_buf[19] = failing_lba & 0x000000ff;
6316 sense_buf[0] = 0x70;
6317 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
6318 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
6319 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
6321 /* Illegal request */
6322 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
6323 (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
6324 sense_buf[7] = 10; /* additional length */
6326 /* IOARCB was in error */
6327 if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
6328 sense_buf[15] = 0xC0;
6329 else /* Parameter data was invalid */
6330 sense_buf[15] = 0x80;
6333 ((IPR_FIELD_POINTER_MASK &
6334 be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
6336 (IPR_FIELD_POINTER_MASK &
6337 be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
6339 if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
6340 if (ipr_is_vset_device(res))
6341 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6343 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
6345 sense_buf[0] |= 0x80; /* Or in the Valid bit */
6346 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
6347 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
6348 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
6349 sense_buf[6] = failing_lba & 0x000000ff;
6352 sense_buf[7] = 6; /* additional length */
6358 * ipr_get_autosense - Copy autosense data to sense buffer
6359 * @ipr_cmd: ipr command struct
6361 * This function copies the autosense buffer to the buffer
6362 * in the scsi_cmd, if there is autosense available.
6365 * 1 if autosense was available / 0 if not
6367 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
6369 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6370 struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
6372 if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
6375 if (ipr_cmd->ioa_cfg->sis64)
6376 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
6377 min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
6378 SCSI_SENSE_BUFFERSIZE));
6380 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
6381 min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
6382 SCSI_SENSE_BUFFERSIZE));
6387 * ipr_erp_start - Process an error response for a SCSI op
6388 * @ioa_cfg: ioa config struct
6389 * @ipr_cmd: ipr command struct
6391 * This function determines whether or not to initiate ERP
6392 * on the affected device.
6397 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
6398 struct ipr_cmnd *ipr_cmd)
6400 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6401 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6402 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6403 u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
6406 __ipr_scsi_eh_done(ipr_cmd);
6410 if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
6411 ipr_gen_sense(ipr_cmd);
6413 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6415 switch (masked_ioasc) {
6416 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
6417 if (ipr_is_naca_model(res))
6418 scsi_cmd->result |= (DID_ABORT << 16);
6420 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6422 case IPR_IOASC_IR_RESOURCE_HANDLE:
6423 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
6424 scsi_cmd->result |= (DID_NO_CONNECT << 16);
6426 case IPR_IOASC_HW_SEL_TIMEOUT:
6427 scsi_cmd->result |= (DID_NO_CONNECT << 16);
6428 if (!ipr_is_naca_model(res))
6429 res->needs_sync_complete = 1;
6431 case IPR_IOASC_SYNC_REQUIRED:
6433 res->needs_sync_complete = 1;
6434 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6436 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
6437 case IPR_IOASA_IR_DUAL_IOA_DISABLED:
6439 * exception: do not set DID_PASSTHROUGH on CHECK CONDITION
6440 * so SCSI mid-layer and upper layers handle it accordingly.
6442 if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION)
6443 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
6445 case IPR_IOASC_BUS_WAS_RESET:
6446 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
6448 * Report the bus reset and ask for a retry. The device
6449 * will give CC/UA the next command.
6451 if (!res->resetting_device)
6452 scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
6453 scsi_cmd->result |= (DID_ERROR << 16);
6454 if (!ipr_is_naca_model(res))
6455 res->needs_sync_complete = 1;
6457 case IPR_IOASC_HW_DEV_BUS_STATUS:
6458 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
6459 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
6460 if (!ipr_get_autosense(ipr_cmd)) {
6461 if (!ipr_is_naca_model(res)) {
6462 ipr_erp_cancel_all(ipr_cmd);
6467 if (!ipr_is_naca_model(res))
6468 res->needs_sync_complete = 1;
6470 case IPR_IOASC_NR_INIT_CMD_REQUIRED:
6472 case IPR_IOASC_IR_NON_OPTIMIZED:
6473 if (res->raw_mode) {
6475 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6477 scsi_cmd->result |= (DID_ERROR << 16);
6480 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6481 scsi_cmd->result |= (DID_ERROR << 16);
6482 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
6483 res->needs_sync_complete = 1;
6487 scsi_dma_unmap(ipr_cmd->scsi_cmd);
6488 scsi_cmd->scsi_done(scsi_cmd);
6489 if (ipr_cmd->eh_comp)
6490 complete(ipr_cmd->eh_comp);
6491 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6495 * ipr_scsi_done - mid-layer done function
6496 * @ipr_cmd: ipr command struct
6498 * This function is invoked by the interrupt handler for
6499 * ops generated by the SCSI mid-layer
6504 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
6506 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6507 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6508 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6509 unsigned long lock_flags;
6511 scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
6513 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
6514 scsi_dma_unmap(scsi_cmd);
6516 spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags);
6517 scsi_cmd->scsi_done(scsi_cmd);
6518 if (ipr_cmd->eh_comp)
6519 complete(ipr_cmd->eh_comp);
6520 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6521 spin_unlock_irqrestore(ipr_cmd->hrrq->lock, lock_flags);
6523 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6524 spin_lock(&ipr_cmd->hrrq->_lock);
6525 ipr_erp_start(ioa_cfg, ipr_cmd);
6526 spin_unlock(&ipr_cmd->hrrq->_lock);
6527 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6532 * ipr_queuecommand - Queue a mid-layer request
6533 * @shost: scsi host struct
6534 * @scsi_cmd: scsi command struct
6536 * This function queues a request generated by the mid-layer.
6540 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6541 * SCSI_MLQUEUE_HOST_BUSY if host is busy
6543 static int ipr_queuecommand(struct Scsi_Host *shost,
6544 struct scsi_cmnd *scsi_cmd)
6546 struct ipr_ioa_cfg *ioa_cfg;
6547 struct ipr_resource_entry *res;
6548 struct ipr_ioarcb *ioarcb;
6549 struct ipr_cmnd *ipr_cmd;
6550 unsigned long hrrq_flags, lock_flags;
6552 struct ipr_hrr_queue *hrrq;
6555 ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
6557 scsi_cmd->result = (DID_OK << 16);
6558 res = scsi_cmd->device->hostdata;
6560 if (ipr_is_gata(res) && res->sata_port) {
6561 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6562 rc = ata_sas_queuecmd(scsi_cmd, res->sata_port->ap);
6563 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6567 hrrq_id = ipr_get_hrrq_index(ioa_cfg);
6568 hrrq = &ioa_cfg->hrrq[hrrq_id];
6570 spin_lock_irqsave(hrrq->lock, hrrq_flags);
6572 * We are currently blocking all devices due to a host reset
6573 * We have told the host to stop giving us new requests, but
6574 * ERP ops don't count. FIXME
6576 if (unlikely(!hrrq->allow_cmds && !hrrq->ioa_is_dead && !hrrq->removing_ioa)) {
6577 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6578 return SCSI_MLQUEUE_HOST_BUSY;
6582 * FIXME - Create scsi_set_host_offline interface
6583 * and the ioa_is_dead check can be removed
6585 if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) {
6586 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6590 ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
6591 if (ipr_cmd == NULL) {
6592 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6593 return SCSI_MLQUEUE_HOST_BUSY;
6595 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6597 ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done);
6598 ioarcb = &ipr_cmd->ioarcb;
6600 memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
6601 ipr_cmd->scsi_cmd = scsi_cmd;
6602 ipr_cmd->done = ipr_scsi_eh_done;
6604 if (ipr_is_gscsi(res)) {
6605 if (scsi_cmd->underflow == 0)
6606 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6608 if (res->reset_occurred) {
6609 res->reset_occurred = 0;
6610 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
6614 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
6615 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
6617 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
6618 if (scsi_cmd->flags & SCMD_TAGGED)
6619 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK;
6621 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
6624 if (scsi_cmd->cmnd[0] >= 0xC0 &&
6625 (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE)) {
6626 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
6628 if (res->raw_mode && ipr_is_af_dasd_device(res)) {
6629 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE;
6631 if (scsi_cmd->underflow == 0)
6632 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6636 rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
6638 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
6640 spin_lock_irqsave(hrrq->lock, hrrq_flags);
6641 if (unlikely(rc || (!hrrq->allow_cmds && !hrrq->ioa_is_dead))) {
6642 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6643 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6645 scsi_dma_unmap(scsi_cmd);
6646 return SCSI_MLQUEUE_HOST_BUSY;
6649 if (unlikely(hrrq->ioa_is_dead)) {
6650 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6651 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6652 scsi_dma_unmap(scsi_cmd);
6656 ioarcb->res_handle = res->res_handle;
6657 if (res->needs_sync_complete) {
6658 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
6659 res->needs_sync_complete = 0;
6661 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_pending_q);
6662 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
6663 ipr_send_command(ipr_cmd);
6664 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6668 spin_lock_irqsave(hrrq->lock, hrrq_flags);
6669 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
6670 scsi_cmd->result = (DID_NO_CONNECT << 16);
6671 scsi_cmd->scsi_done(scsi_cmd);
6672 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6677 * ipr_ioctl - IOCTL handler
6678 * @sdev: scsi device struct
6683 * 0 on success / other on failure
6685 static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
6687 struct ipr_resource_entry *res;
6689 res = (struct ipr_resource_entry *)sdev->hostdata;
6690 if (res && ipr_is_gata(res)) {
6691 if (cmd == HDIO_GET_IDENTITY)
6693 return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
6700 * ipr_info - Get information about the card/driver
6701 * @scsi_host: scsi host struct
6704 * pointer to buffer with description string
6706 static const char *ipr_ioa_info(struct Scsi_Host *host)
6708 static char buffer[512];
6709 struct ipr_ioa_cfg *ioa_cfg;
6710 unsigned long lock_flags = 0;
6712 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
6714 spin_lock_irqsave(host->host_lock, lock_flags);
6715 sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
6716 spin_unlock_irqrestore(host->host_lock, lock_flags);
6721 static struct scsi_host_template driver_template = {
6722 .module = THIS_MODULE,
6724 .info = ipr_ioa_info,
6726 .queuecommand = ipr_queuecommand,
6727 .eh_abort_handler = ipr_eh_abort,
6728 .eh_device_reset_handler = ipr_eh_dev_reset,
6729 .eh_host_reset_handler = ipr_eh_host_reset,
6730 .slave_alloc = ipr_slave_alloc,
6731 .slave_configure = ipr_slave_configure,
6732 .slave_destroy = ipr_slave_destroy,
6733 .scan_finished = ipr_scan_finished,
6734 .target_alloc = ipr_target_alloc,
6735 .target_destroy = ipr_target_destroy,
6736 .change_queue_depth = ipr_change_queue_depth,
6737 .bios_param = ipr_biosparam,
6738 .can_queue = IPR_MAX_COMMANDS,
6740 .sg_tablesize = IPR_MAX_SGLIST,
6741 .max_sectors = IPR_IOA_MAX_SECTORS,
6742 .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
6743 .use_clustering = ENABLE_CLUSTERING,
6744 .shost_attrs = ipr_ioa_attrs,
6745 .sdev_attrs = ipr_dev_attrs,
6746 .proc_name = IPR_NAME,
6750 * ipr_ata_phy_reset - libata phy_reset handler
6751 * @ap: ata port to reset
6754 static void ipr_ata_phy_reset(struct ata_port *ap)
6756 unsigned long flags;
6757 struct ipr_sata_port *sata_port = ap->private_data;
6758 struct ipr_resource_entry *res = sata_port->res;
6759 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6763 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6764 while (ioa_cfg->in_reset_reload) {
6765 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6766 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6767 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6770 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds)
6773 rc = ipr_device_reset(ioa_cfg, res);
6776 ap->link.device[0].class = ATA_DEV_NONE;
6780 ap->link.device[0].class = res->ata_class;
6781 if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
6782 ap->link.device[0].class = ATA_DEV_NONE;
6785 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6790 * ipr_ata_post_internal - Cleanup after an internal command
6791 * @qc: ATA queued command
6796 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
6798 struct ipr_sata_port *sata_port = qc->ap->private_data;
6799 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6800 struct ipr_cmnd *ipr_cmd;
6801 struct ipr_hrr_queue *hrrq;
6802 unsigned long flags;
6804 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6805 while (ioa_cfg->in_reset_reload) {
6806 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6807 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6808 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6811 for_each_hrrq(hrrq, ioa_cfg) {
6812 spin_lock(&hrrq->_lock);
6813 list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
6814 if (ipr_cmd->qc == qc) {
6815 ipr_device_reset(ioa_cfg, sata_port->res);
6819 spin_unlock(&hrrq->_lock);
6821 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6825 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6826 * @regs: destination
6827 * @tf: source ATA taskfile
6832 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
6833 struct ata_taskfile *tf)
6835 regs->feature = tf->feature;
6836 regs->nsect = tf->nsect;
6837 regs->lbal = tf->lbal;
6838 regs->lbam = tf->lbam;
6839 regs->lbah = tf->lbah;
6840 regs->device = tf->device;
6841 regs->command = tf->command;
6842 regs->hob_feature = tf->hob_feature;
6843 regs->hob_nsect = tf->hob_nsect;
6844 regs->hob_lbal = tf->hob_lbal;
6845 regs->hob_lbam = tf->hob_lbam;
6846 regs->hob_lbah = tf->hob_lbah;
6847 regs->ctl = tf->ctl;
6851 * ipr_sata_done - done function for SATA commands
6852 * @ipr_cmd: ipr command struct
6854 * This function is invoked by the interrupt handler for
6855 * ops generated by the SCSI mid-layer to SATA devices
6860 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
6862 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6863 struct ata_queued_cmd *qc = ipr_cmd->qc;
6864 struct ipr_sata_port *sata_port = qc->ap->private_data;
6865 struct ipr_resource_entry *res = sata_port->res;
6866 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6868 spin_lock(&ipr_cmd->hrrq->_lock);
6869 if (ipr_cmd->ioa_cfg->sis64)
6870 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
6871 sizeof(struct ipr_ioasa_gata));
6873 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
6874 sizeof(struct ipr_ioasa_gata));
6875 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6877 if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
6878 scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
6880 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6881 qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
6883 qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
6884 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6885 spin_unlock(&ipr_cmd->hrrq->_lock);
6886 ata_qc_complete(qc);
6890 * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6891 * @ipr_cmd: ipr command struct
6892 * @qc: ATA queued command
6895 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
6896 struct ata_queued_cmd *qc)
6898 u32 ioadl_flags = 0;
6899 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6900 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64;
6901 struct ipr_ioadl64_desc *last_ioadl64 = NULL;
6902 int len = qc->nbytes;
6903 struct scatterlist *sg;
6905 dma_addr_t dma_addr = ipr_cmd->dma_addr;
6910 if (qc->dma_dir == DMA_TO_DEVICE) {
6911 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6912 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6913 } else if (qc->dma_dir == DMA_FROM_DEVICE)
6914 ioadl_flags = IPR_IOADL_FLAGS_READ;
6916 ioarcb->data_transfer_length = cpu_to_be32(len);
6918 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
6919 ioarcb->u.sis64_addr_data.data_ioadl_addr =
6920 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64));
6922 for_each_sg(qc->sg, sg, qc->n_elem, si) {
6923 ioadl64->flags = cpu_to_be32(ioadl_flags);
6924 ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
6925 ioadl64->address = cpu_to_be64(sg_dma_address(sg));
6927 last_ioadl64 = ioadl64;
6931 if (likely(last_ioadl64))
6932 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6936 * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6937 * @ipr_cmd: ipr command struct
6938 * @qc: ATA queued command
6941 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
6942 struct ata_queued_cmd *qc)
6944 u32 ioadl_flags = 0;
6945 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6946 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
6947 struct ipr_ioadl_desc *last_ioadl = NULL;
6948 int len = qc->nbytes;
6949 struct scatterlist *sg;
6955 if (qc->dma_dir == DMA_TO_DEVICE) {
6956 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6957 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6958 ioarcb->data_transfer_length = cpu_to_be32(len);
6960 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6961 } else if (qc->dma_dir == DMA_FROM_DEVICE) {
6962 ioadl_flags = IPR_IOADL_FLAGS_READ;
6963 ioarcb->read_data_transfer_length = cpu_to_be32(len);
6964 ioarcb->read_ioadl_len =
6965 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6968 for_each_sg(qc->sg, sg, qc->n_elem, si) {
6969 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6970 ioadl->address = cpu_to_be32(sg_dma_address(sg));
6976 if (likely(last_ioadl))
6977 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6981 * ipr_qc_defer - Get a free ipr_cmd
6982 * @qc: queued command
6987 static int ipr_qc_defer(struct ata_queued_cmd *qc)
6989 struct ata_port *ap = qc->ap;
6990 struct ipr_sata_port *sata_port = ap->private_data;
6991 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6992 struct ipr_cmnd *ipr_cmd;
6993 struct ipr_hrr_queue *hrrq;
6996 hrrq_id = ipr_get_hrrq_index(ioa_cfg);
6997 hrrq = &ioa_cfg->hrrq[hrrq_id];
6999 qc->lldd_task = NULL;
7000 spin_lock(&hrrq->_lock);
7001 if (unlikely(hrrq->ioa_is_dead)) {
7002 spin_unlock(&hrrq->_lock);
7006 if (unlikely(!hrrq->allow_cmds)) {
7007 spin_unlock(&hrrq->_lock);
7008 return ATA_DEFER_LINK;
7011 ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
7012 if (ipr_cmd == NULL) {
7013 spin_unlock(&hrrq->_lock);
7014 return ATA_DEFER_LINK;
7017 qc->lldd_task = ipr_cmd;
7018 spin_unlock(&hrrq->_lock);
7023 * ipr_qc_issue - Issue a SATA qc to a device
7024 * @qc: queued command
7029 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
7031 struct ata_port *ap = qc->ap;
7032 struct ipr_sata_port *sata_port = ap->private_data;
7033 struct ipr_resource_entry *res = sata_port->res;
7034 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
7035 struct ipr_cmnd *ipr_cmd;
7036 struct ipr_ioarcb *ioarcb;
7037 struct ipr_ioarcb_ata_regs *regs;
7039 if (qc->lldd_task == NULL)
7042 ipr_cmd = qc->lldd_task;
7043 if (ipr_cmd == NULL)
7044 return AC_ERR_SYSTEM;
7046 qc->lldd_task = NULL;
7047 spin_lock(&ipr_cmd->hrrq->_lock);
7048 if (unlikely(!ipr_cmd->hrrq->allow_cmds ||
7049 ipr_cmd->hrrq->ioa_is_dead)) {
7050 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7051 spin_unlock(&ipr_cmd->hrrq->_lock);
7052 return AC_ERR_SYSTEM;
7055 ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
7056 ioarcb = &ipr_cmd->ioarcb;
7058 if (ioa_cfg->sis64) {
7059 regs = &ipr_cmd->i.ata_ioadl.regs;
7060 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
7062 regs = &ioarcb->u.add_data.u.regs;
7064 memset(regs, 0, sizeof(*regs));
7065 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
7067 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
7069 ipr_cmd->done = ipr_sata_done;
7070 ipr_cmd->ioarcb.res_handle = res->res_handle;
7071 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
7072 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
7073 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
7074 ipr_cmd->dma_use_sg = qc->n_elem;
7077 ipr_build_ata_ioadl64(ipr_cmd, qc);
7079 ipr_build_ata_ioadl(ipr_cmd, qc);
7081 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
7082 ipr_copy_sata_tf(regs, &qc->tf);
7083 memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
7084 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
7086 switch (qc->tf.protocol) {
7087 case ATA_PROT_NODATA:
7092 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7095 case ATAPI_PROT_PIO:
7096 case ATAPI_PROT_NODATA:
7097 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7100 case ATAPI_PROT_DMA:
7101 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7102 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7107 spin_unlock(&ipr_cmd->hrrq->_lock);
7108 return AC_ERR_INVALID;
7111 ipr_send_command(ipr_cmd);
7112 spin_unlock(&ipr_cmd->hrrq->_lock);
7118 * ipr_qc_fill_rtf - Read result TF
7119 * @qc: ATA queued command
7124 static bool ipr_qc_fill_rtf(struct ata_queued_cmd *qc)
7126 struct ipr_sata_port *sata_port = qc->ap->private_data;
7127 struct ipr_ioasa_gata *g = &sata_port->ioasa;
7128 struct ata_taskfile *tf = &qc->result_tf;
7130 tf->feature = g->error;
7131 tf->nsect = g->nsect;
7135 tf->device = g->device;
7136 tf->command = g->status;
7137 tf->hob_nsect = g->hob_nsect;
7138 tf->hob_lbal = g->hob_lbal;
7139 tf->hob_lbam = g->hob_lbam;
7140 tf->hob_lbah = g->hob_lbah;
7145 static struct ata_port_operations ipr_sata_ops = {
7146 .phy_reset = ipr_ata_phy_reset,
7147 .hardreset = ipr_sata_reset,
7148 .post_internal_cmd = ipr_ata_post_internal,
7149 .qc_prep = ata_noop_qc_prep,
7150 .qc_defer = ipr_qc_defer,
7151 .qc_issue = ipr_qc_issue,
7152 .qc_fill_rtf = ipr_qc_fill_rtf,
7153 .port_start = ata_sas_port_start,
7154 .port_stop = ata_sas_port_stop
7157 static struct ata_port_info sata_port_info = {
7158 .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
7160 .pio_mask = ATA_PIO4_ONLY,
7161 .mwdma_mask = ATA_MWDMA2,
7162 .udma_mask = ATA_UDMA6,
7163 .port_ops = &ipr_sata_ops
7166 #ifdef CONFIG_PPC_PSERIES
7167 static const u16 ipr_blocked_processors[] = {
7179 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
7180 * @ioa_cfg: ioa cfg struct
7182 * Adapters that use Gemstone revision < 3.1 do not work reliably on
7183 * certain pSeries hardware. This function determines if the given
7184 * adapter is in one of these confgurations or not.
7187 * 1 if adapter is not supported / 0 if adapter is supported
7189 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
7193 if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
7194 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
7195 if (pvr_version_is(ipr_blocked_processors[i]))
7202 #define ipr_invalid_adapter(ioa_cfg) 0
7206 * ipr_ioa_bringdown_done - IOA bring down completion.
7207 * @ipr_cmd: ipr command struct
7209 * This function processes the completion of an adapter bring down.
7210 * It wakes any reset sleepers.
7215 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
7217 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7221 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
7223 ioa_cfg->scsi_unblock = 1;
7224 schedule_work(&ioa_cfg->work_q);
7227 ioa_cfg->in_reset_reload = 0;
7228 ioa_cfg->reset_retries = 0;
7229 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
7230 spin_lock(&ioa_cfg->hrrq[i]._lock);
7231 ioa_cfg->hrrq[i].ioa_is_dead = 1;
7232 spin_unlock(&ioa_cfg->hrrq[i]._lock);
7236 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7237 wake_up_all(&ioa_cfg->reset_wait_q);
7240 return IPR_RC_JOB_RETURN;
7244 * ipr_ioa_reset_done - IOA reset completion.
7245 * @ipr_cmd: ipr command struct
7247 * This function processes the completion of an adapter reset.
7248 * It schedules any necessary mid-layer add/removes and
7249 * wakes any reset sleepers.
7254 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
7256 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7257 struct ipr_resource_entry *res;
7261 ioa_cfg->in_reset_reload = 0;
7262 for (j = 0; j < ioa_cfg->hrrq_num; j++) {
7263 spin_lock(&ioa_cfg->hrrq[j]._lock);
7264 ioa_cfg->hrrq[j].allow_cmds = 1;
7265 spin_unlock(&ioa_cfg->hrrq[j]._lock);
7268 ioa_cfg->reset_cmd = NULL;
7269 ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
7271 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
7272 if (res->add_to_ml || res->del_from_ml) {
7277 schedule_work(&ioa_cfg->work_q);
7279 for (j = 0; j < IPR_NUM_HCAMS; j++) {
7280 list_del_init(&ioa_cfg->hostrcb[j]->queue);
7281 if (j < IPR_NUM_LOG_HCAMS)
7282 ipr_send_hcam(ioa_cfg,
7283 IPR_HCAM_CDB_OP_CODE_LOG_DATA,
7284 ioa_cfg->hostrcb[j]);
7286 ipr_send_hcam(ioa_cfg,
7287 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
7288 ioa_cfg->hostrcb[j]);
7291 scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
7292 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
7294 ioa_cfg->reset_retries = 0;
7295 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7296 wake_up_all(&ioa_cfg->reset_wait_q);
7298 ioa_cfg->scsi_unblock = 1;
7299 schedule_work(&ioa_cfg->work_q);
7301 return IPR_RC_JOB_RETURN;
7305 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7306 * @supported_dev: supported device struct
7307 * @vpids: vendor product id struct
7312 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
7313 struct ipr_std_inq_vpids *vpids)
7315 memset(supported_dev, 0, sizeof(struct ipr_supported_device));
7316 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
7317 supported_dev->num_records = 1;
7318 supported_dev->data_length =
7319 cpu_to_be16(sizeof(struct ipr_supported_device));
7320 supported_dev->reserved = 0;
7324 * ipr_set_supported_devs - Send Set Supported Devices for a device
7325 * @ipr_cmd: ipr command struct
7327 * This function sends a Set Supported Devices to the adapter
7330 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7332 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
7334 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7335 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
7336 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7337 struct ipr_resource_entry *res = ipr_cmd->u.res;
7339 ipr_cmd->job_step = ipr_ioa_reset_done;
7341 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
7342 if (!ipr_is_scsi_disk(res))
7345 ipr_cmd->u.res = res;
7346 ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
7348 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7349 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7350 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7352 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
7353 ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
7354 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
7355 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
7357 ipr_init_ioadl(ipr_cmd,
7358 ioa_cfg->vpd_cbs_dma +
7359 offsetof(struct ipr_misc_cbs, supp_dev),
7360 sizeof(struct ipr_supported_device),
7361 IPR_IOADL_FLAGS_WRITE_LAST);
7363 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7364 IPR_SET_SUP_DEVICE_TIMEOUT);
7366 if (!ioa_cfg->sis64)
7367 ipr_cmd->job_step = ipr_set_supported_devs;
7369 return IPR_RC_JOB_RETURN;
7373 return IPR_RC_JOB_CONTINUE;
7377 * ipr_get_mode_page - Locate specified mode page
7378 * @mode_pages: mode page buffer
7379 * @page_code: page code to find
7380 * @len: minimum required length for mode page
7383 * pointer to mode page / NULL on failure
7385 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
7386 u32 page_code, u32 len)
7388 struct ipr_mode_page_hdr *mode_hdr;
7392 if (!mode_pages || (mode_pages->hdr.length == 0))
7395 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
7396 mode_hdr = (struct ipr_mode_page_hdr *)
7397 (mode_pages->data + mode_pages->hdr.block_desc_len);
7400 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
7401 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
7405 page_length = (sizeof(struct ipr_mode_page_hdr) +
7406 mode_hdr->page_length);
7407 length -= page_length;
7408 mode_hdr = (struct ipr_mode_page_hdr *)
7409 ((unsigned long)mode_hdr + page_length);
7416 * ipr_check_term_power - Check for term power errors
7417 * @ioa_cfg: ioa config struct
7418 * @mode_pages: IOAFP mode pages buffer
7420 * Check the IOAFP's mode page 28 for term power errors
7425 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
7426 struct ipr_mode_pages *mode_pages)
7430 struct ipr_dev_bus_entry *bus;
7431 struct ipr_mode_page28 *mode_page;
7433 mode_page = ipr_get_mode_page(mode_pages, 0x28,
7434 sizeof(struct ipr_mode_page28));
7436 entry_length = mode_page->entry_length;
7438 bus = mode_page->bus;
7440 for (i = 0; i < mode_page->num_entries; i++) {
7441 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
7442 dev_err(&ioa_cfg->pdev->dev,
7443 "Term power is absent on scsi bus %d\n",
7447 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
7452 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7453 * @ioa_cfg: ioa config struct
7455 * Looks through the config table checking for SES devices. If
7456 * the SES device is in the SES table indicating a maximum SCSI
7457 * bus speed, the speed is limited for the bus.
7462 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
7467 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
7468 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
7469 ioa_cfg->bus_attr[i].bus_width);
7471 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
7472 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
7477 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7478 * @ioa_cfg: ioa config struct
7479 * @mode_pages: mode page 28 buffer
7481 * Updates mode page 28 based on driver configuration
7486 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
7487 struct ipr_mode_pages *mode_pages)
7489 int i, entry_length;
7490 struct ipr_dev_bus_entry *bus;
7491 struct ipr_bus_attributes *bus_attr;
7492 struct ipr_mode_page28 *mode_page;
7494 mode_page = ipr_get_mode_page(mode_pages, 0x28,
7495 sizeof(struct ipr_mode_page28));
7497 entry_length = mode_page->entry_length;
7499 /* Loop for each device bus entry */
7500 for (i = 0, bus = mode_page->bus;
7501 i < mode_page->num_entries;
7502 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
7503 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
7504 dev_err(&ioa_cfg->pdev->dev,
7505 "Invalid resource address reported: 0x%08X\n",
7506 IPR_GET_PHYS_LOC(bus->res_addr));
7510 bus_attr = &ioa_cfg->bus_attr[i];
7511 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
7512 bus->bus_width = bus_attr->bus_width;
7513 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
7514 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
7515 if (bus_attr->qas_enabled)
7516 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
7518 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
7523 * ipr_build_mode_select - Build a mode select command
7524 * @ipr_cmd: ipr command struct
7525 * @res_handle: resource handle to send command to
7526 * @parm: Byte 2 of Mode Sense command
7527 * @dma_addr: DMA buffer address
7528 * @xfer_len: data transfer length
7533 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
7534 __be32 res_handle, u8 parm,
7535 dma_addr_t dma_addr, u8 xfer_len)
7537 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7539 ioarcb->res_handle = res_handle;
7540 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7541 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7542 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
7543 ioarcb->cmd_pkt.cdb[1] = parm;
7544 ioarcb->cmd_pkt.cdb[4] = xfer_len;
7546 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
7550 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7551 * @ipr_cmd: ipr command struct
7553 * This function sets up the SCSI bus attributes and sends
7554 * a Mode Select for Page 28 to activate them.
7559 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
7561 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7562 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7566 ipr_scsi_bus_speed_limit(ioa_cfg);
7567 ipr_check_term_power(ioa_cfg, mode_pages);
7568 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
7569 length = mode_pages->hdr.length + 1;
7570 mode_pages->hdr.length = 0;
7572 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7573 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7576 ipr_cmd->job_step = ipr_set_supported_devs;
7577 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7578 struct ipr_resource_entry, queue);
7579 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7582 return IPR_RC_JOB_RETURN;
7586 * ipr_build_mode_sense - Builds a mode sense command
7587 * @ipr_cmd: ipr command struct
7588 * @res: resource entry struct
7589 * @parm: Byte 2 of mode sense command
7590 * @dma_addr: DMA address of mode sense buffer
7591 * @xfer_len: Size of DMA buffer
7596 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
7598 u8 parm, dma_addr_t dma_addr, u8 xfer_len)
7600 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7602 ioarcb->res_handle = res_handle;
7603 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
7604 ioarcb->cmd_pkt.cdb[2] = parm;
7605 ioarcb->cmd_pkt.cdb[4] = xfer_len;
7606 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7608 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
7612 * ipr_reset_cmd_failed - Handle failure of IOA reset command
7613 * @ipr_cmd: ipr command struct
7615 * This function handles the failure of an IOA bringup command.
7620 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
7622 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7623 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7625 dev_err(&ioa_cfg->pdev->dev,
7626 "0x%02X failed with IOASC: 0x%08X\n",
7627 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
7629 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
7630 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7631 return IPR_RC_JOB_RETURN;
7635 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7636 * @ipr_cmd: ipr command struct
7638 * This function handles the failure of a Mode Sense to the IOAFP.
7639 * Some adapters do not handle all mode pages.
7642 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7644 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
7646 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7647 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7649 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7650 ipr_cmd->job_step = ipr_set_supported_devs;
7651 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7652 struct ipr_resource_entry, queue);
7653 return IPR_RC_JOB_CONTINUE;
7656 return ipr_reset_cmd_failed(ipr_cmd);
7660 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7661 * @ipr_cmd: ipr command struct
7663 * This function send a Page 28 mode sense to the IOA to
7664 * retrieve SCSI bus attributes.
7669 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
7671 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7674 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7675 0x28, ioa_cfg->vpd_cbs_dma +
7676 offsetof(struct ipr_misc_cbs, mode_pages),
7677 sizeof(struct ipr_mode_pages));
7679 ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
7680 ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
7682 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7685 return IPR_RC_JOB_RETURN;
7689 * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7690 * @ipr_cmd: ipr command struct
7692 * This function enables dual IOA RAID support if possible.
7697 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
7699 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7700 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7701 struct ipr_mode_page24 *mode_page;
7705 mode_page = ipr_get_mode_page(mode_pages, 0x24,
7706 sizeof(struct ipr_mode_page24));
7709 mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
7711 length = mode_pages->hdr.length + 1;
7712 mode_pages->hdr.length = 0;
7714 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7715 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7718 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7719 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7722 return IPR_RC_JOB_RETURN;
7726 * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7727 * @ipr_cmd: ipr command struct
7729 * This function handles the failure of a Mode Sense to the IOAFP.
7730 * Some adapters do not handle all mode pages.
7733 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7735 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
7737 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7739 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7740 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7741 return IPR_RC_JOB_CONTINUE;
7744 return ipr_reset_cmd_failed(ipr_cmd);
7748 * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7749 * @ipr_cmd: ipr command struct
7751 * This function send a mode sense to the IOA to retrieve
7752 * the IOA Advanced Function Control mode page.
7757 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
7759 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7762 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7763 0x24, ioa_cfg->vpd_cbs_dma +
7764 offsetof(struct ipr_misc_cbs, mode_pages),
7765 sizeof(struct ipr_mode_pages));
7767 ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
7768 ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
7770 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7773 return IPR_RC_JOB_RETURN;
7777 * ipr_init_res_table - Initialize the resource table
7778 * @ipr_cmd: ipr command struct
7780 * This function looks through the existing resource table, comparing
7781 * it with the config table. This function will take care of old/new
7782 * devices and schedule adding/removing them from the mid-layer
7786 * IPR_RC_JOB_CONTINUE
7788 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
7790 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7791 struct ipr_resource_entry *res, *temp;
7792 struct ipr_config_table_entry_wrapper cfgtew;
7793 int entries, found, flag, i;
7798 flag = ioa_cfg->u.cfg_table64->hdr64.flags;
7800 flag = ioa_cfg->u.cfg_table->hdr.flags;
7802 if (flag & IPR_UCODE_DOWNLOAD_REQ)
7803 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
7805 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
7806 list_move_tail(&res->queue, &old_res);
7809 entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
7811 entries = ioa_cfg->u.cfg_table->hdr.num_entries;
7813 for (i = 0; i < entries; i++) {
7815 cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
7817 cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
7820 list_for_each_entry_safe(res, temp, &old_res, queue) {
7821 if (ipr_is_same_device(res, &cfgtew)) {
7822 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7829 if (list_empty(&ioa_cfg->free_res_q)) {
7830 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
7835 res = list_entry(ioa_cfg->free_res_q.next,
7836 struct ipr_resource_entry, queue);
7837 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7838 ipr_init_res_entry(res, &cfgtew);
7840 } else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res)))
7841 res->sdev->allow_restart = 1;
7844 ipr_update_res_entry(res, &cfgtew);
7847 list_for_each_entry_safe(res, temp, &old_res, queue) {
7849 res->del_from_ml = 1;
7850 res->res_handle = IPR_INVALID_RES_HANDLE;
7851 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7855 list_for_each_entry_safe(res, temp, &old_res, queue) {
7856 ipr_clear_res_target(res);
7857 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
7860 if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
7861 ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
7863 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7866 return IPR_RC_JOB_CONTINUE;
7870 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7871 * @ipr_cmd: ipr command struct
7873 * This function sends a Query IOA Configuration command
7874 * to the adapter to retrieve the IOA configuration table.
7879 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
7881 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7882 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7883 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
7884 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
7887 if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
7888 ioa_cfg->dual_raid = 1;
7889 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
7890 ucode_vpd->major_release, ucode_vpd->card_type,
7891 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
7892 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7893 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7895 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
7896 ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
7897 ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
7898 ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
7900 ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
7901 IPR_IOADL_FLAGS_READ_LAST);
7903 ipr_cmd->job_step = ipr_init_res_table;
7905 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7908 return IPR_RC_JOB_RETURN;
7911 static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd)
7913 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7915 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT)
7916 return IPR_RC_JOB_CONTINUE;
7918 return ipr_reset_cmd_failed(ipr_cmd);
7921 static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd,
7922 __be32 res_handle, u8 sa_code)
7924 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7926 ioarcb->res_handle = res_handle;
7927 ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION;
7928 ioarcb->cmd_pkt.cdb[1] = sa_code;
7929 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7933 * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7939 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd)
7941 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7942 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7943 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
7947 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
7949 if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) {
7950 ipr_build_ioa_service_action(ipr_cmd,
7951 cpu_to_be32(IPR_IOA_RES_HANDLE),
7952 IPR_IOA_SA_CHANGE_CACHE_PARAMS);
7954 ioarcb->cmd_pkt.cdb[2] = 0x40;
7956 ipr_cmd->job_step_failed = ipr_ioa_service_action_failed;
7957 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7958 IPR_SET_SUP_DEVICE_TIMEOUT);
7961 return IPR_RC_JOB_RETURN;
7965 return IPR_RC_JOB_CONTINUE;
7969 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7970 * @ipr_cmd: ipr command struct
7972 * This utility function sends an inquiry to the adapter.
7977 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
7978 dma_addr_t dma_addr, u8 xfer_len)
7980 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7983 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7984 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7986 ioarcb->cmd_pkt.cdb[0] = INQUIRY;
7987 ioarcb->cmd_pkt.cdb[1] = flags;
7988 ioarcb->cmd_pkt.cdb[2] = page;
7989 ioarcb->cmd_pkt.cdb[4] = xfer_len;
7991 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
7993 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7998 * ipr_inquiry_page_supported - Is the given inquiry page supported
7999 * @page0: inquiry page 0 buffer
8002 * This function determines if the specified inquiry page is supported.
8005 * 1 if page is supported / 0 if not
8007 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
8011 for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
8012 if (page0->page[i] == page)
8019 * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
8020 * @ipr_cmd: ipr command struct
8022 * This function sends a Page 0xC4 inquiry to the adapter
8023 * to retrieve software VPD information.
8026 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8028 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd)
8030 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8031 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8032 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
8035 ipr_cmd->job_step = ipr_ioafp_set_caching_parameters;
8036 memset(pageC4, 0, sizeof(*pageC4));
8038 if (ipr_inquiry_page_supported(page0, 0xC4)) {
8039 ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4,
8040 (ioa_cfg->vpd_cbs_dma
8041 + offsetof(struct ipr_misc_cbs,
8043 sizeof(struct ipr_inquiry_pageC4));
8044 return IPR_RC_JOB_RETURN;
8048 return IPR_RC_JOB_CONTINUE;
8052 * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
8053 * @ipr_cmd: ipr command struct
8055 * This function sends a Page 0xD0 inquiry to the adapter
8056 * to retrieve adapter capabilities.
8059 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8061 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
8063 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8064 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8065 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
8068 ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry;
8069 memset(cap, 0, sizeof(*cap));
8071 if (ipr_inquiry_page_supported(page0, 0xD0)) {
8072 ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
8073 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
8074 sizeof(struct ipr_inquiry_cap));
8075 return IPR_RC_JOB_RETURN;
8079 return IPR_RC_JOB_CONTINUE;
8083 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
8084 * @ipr_cmd: ipr command struct
8086 * This function sends a Page 3 inquiry to the adapter
8087 * to retrieve software VPD information.
8090 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8092 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
8094 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8098 ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
8100 ipr_ioafp_inquiry(ipr_cmd, 1, 3,
8101 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
8102 sizeof(struct ipr_inquiry_page3));
8105 return IPR_RC_JOB_RETURN;
8109 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
8110 * @ipr_cmd: ipr command struct
8112 * This function sends a Page 0 inquiry to the adapter
8113 * to retrieve supported inquiry pages.
8116 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8118 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
8120 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8125 /* Grab the type out of the VPD and store it away */
8126 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
8128 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
8130 if (ipr_invalid_adapter(ioa_cfg)) {
8131 dev_err(&ioa_cfg->pdev->dev,
8132 "Adapter not supported in this hardware configuration.\n");
8134 if (!ipr_testmode) {
8135 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
8136 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
8137 list_add_tail(&ipr_cmd->queue,
8138 &ioa_cfg->hrrq->hrrq_free_q);
8139 return IPR_RC_JOB_RETURN;
8143 ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
8145 ipr_ioafp_inquiry(ipr_cmd, 1, 0,
8146 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
8147 sizeof(struct ipr_inquiry_page0));
8150 return IPR_RC_JOB_RETURN;
8154 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
8155 * @ipr_cmd: ipr command struct
8157 * This function sends a standard inquiry to the adapter.
8162 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
8164 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8167 ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
8169 ipr_ioafp_inquiry(ipr_cmd, 0, 0,
8170 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
8171 sizeof(struct ipr_ioa_vpd));
8174 return IPR_RC_JOB_RETURN;
8178 * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
8179 * @ipr_cmd: ipr command struct
8181 * This function send an Identify Host Request Response Queue
8182 * command to establish the HRRQ with the adapter.
8187 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
8189 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8190 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8191 struct ipr_hrr_queue *hrrq;
8194 ipr_cmd->job_step = ipr_ioafp_std_inquiry;
8195 if (ioa_cfg->identify_hrrq_index == 0)
8196 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
8198 if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) {
8199 hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index];
8201 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
8202 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8204 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
8206 ioarcb->cmd_pkt.cdb[1] = 0x1;
8208 if (ioa_cfg->nvectors == 1)
8209 ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE;
8211 ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE;
8213 ioarcb->cmd_pkt.cdb[2] =
8214 ((u64) hrrq->host_rrq_dma >> 24) & 0xff;
8215 ioarcb->cmd_pkt.cdb[3] =
8216 ((u64) hrrq->host_rrq_dma >> 16) & 0xff;
8217 ioarcb->cmd_pkt.cdb[4] =
8218 ((u64) hrrq->host_rrq_dma >> 8) & 0xff;
8219 ioarcb->cmd_pkt.cdb[5] =
8220 ((u64) hrrq->host_rrq_dma) & 0xff;
8221 ioarcb->cmd_pkt.cdb[7] =
8222 ((sizeof(u32) * hrrq->size) >> 8) & 0xff;
8223 ioarcb->cmd_pkt.cdb[8] =
8224 (sizeof(u32) * hrrq->size) & 0xff;
8226 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8227 ioarcb->cmd_pkt.cdb[9] =
8228 ioa_cfg->identify_hrrq_index;
8230 if (ioa_cfg->sis64) {
8231 ioarcb->cmd_pkt.cdb[10] =
8232 ((u64) hrrq->host_rrq_dma >> 56) & 0xff;
8233 ioarcb->cmd_pkt.cdb[11] =
8234 ((u64) hrrq->host_rrq_dma >> 48) & 0xff;
8235 ioarcb->cmd_pkt.cdb[12] =
8236 ((u64) hrrq->host_rrq_dma >> 40) & 0xff;
8237 ioarcb->cmd_pkt.cdb[13] =
8238 ((u64) hrrq->host_rrq_dma >> 32) & 0xff;
8241 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8242 ioarcb->cmd_pkt.cdb[14] =
8243 ioa_cfg->identify_hrrq_index;
8245 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
8246 IPR_INTERNAL_TIMEOUT);
8248 if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num)
8249 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8252 return IPR_RC_JOB_RETURN;
8256 return IPR_RC_JOB_CONTINUE;
8260 * ipr_reset_timer_done - Adapter reset timer function
8261 * @ipr_cmd: ipr command struct
8263 * Description: This function is used in adapter reset processing
8264 * for timing events. If the reset_cmd pointer in the IOA
8265 * config struct is not this adapter's we are doing nested
8266 * resets and fail_all_ops will take care of freeing the
8272 static void ipr_reset_timer_done(struct timer_list *t)
8274 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
8275 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8276 unsigned long lock_flags = 0;
8278 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8280 if (ioa_cfg->reset_cmd == ipr_cmd) {
8281 list_del(&ipr_cmd->queue);
8282 ipr_cmd->done(ipr_cmd);
8285 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8289 * ipr_reset_start_timer - Start a timer for adapter reset job
8290 * @ipr_cmd: ipr command struct
8291 * @timeout: timeout value
8293 * Description: This function is used in adapter reset processing
8294 * for timing events. If the reset_cmd pointer in the IOA
8295 * config struct is not this adapter's we are doing nested
8296 * resets and fail_all_ops will take care of freeing the
8302 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
8303 unsigned long timeout)
8307 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8308 ipr_cmd->done = ipr_reset_ioa_job;
8310 ipr_cmd->timer.expires = jiffies + timeout;
8311 ipr_cmd->timer.function = ipr_reset_timer_done;
8312 add_timer(&ipr_cmd->timer);
8316 * ipr_init_ioa_mem - Initialize ioa_cfg control block
8317 * @ioa_cfg: ioa cfg struct
8322 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
8324 struct ipr_hrr_queue *hrrq;
8326 for_each_hrrq(hrrq, ioa_cfg) {
8327 spin_lock(&hrrq->_lock);
8328 memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size);
8330 /* Initialize Host RRQ pointers */
8331 hrrq->hrrq_start = hrrq->host_rrq;
8332 hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1];
8333 hrrq->hrrq_curr = hrrq->hrrq_start;
8334 hrrq->toggle_bit = 1;
8335 spin_unlock(&hrrq->_lock);
8339 ioa_cfg->identify_hrrq_index = 0;
8340 if (ioa_cfg->hrrq_num == 1)
8341 atomic_set(&ioa_cfg->hrrq_index, 0);
8343 atomic_set(&ioa_cfg->hrrq_index, 1);
8345 /* Zero out config table */
8346 memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
8350 * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8351 * @ipr_cmd: ipr command struct
8354 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8356 static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
8358 unsigned long stage, stage_time;
8360 volatile u32 int_reg;
8361 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8364 feedback = readl(ioa_cfg->regs.init_feedback_reg);
8365 stage = feedback & IPR_IPL_INIT_STAGE_MASK;
8366 stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
8368 ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
8370 /* sanity check the stage_time value */
8371 if (stage_time == 0)
8372 stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
8373 else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
8374 stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
8375 else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
8376 stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
8378 if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
8379 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
8380 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8381 stage_time = ioa_cfg->transop_timeout;
8382 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8383 } else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
8384 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8385 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8386 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8387 maskval = IPR_PCII_IPL_STAGE_CHANGE;
8388 maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
8389 writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
8390 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8391 return IPR_RC_JOB_CONTINUE;
8395 ipr_cmd->timer.expires = jiffies + stage_time * HZ;
8396 ipr_cmd->timer.function = ipr_oper_timeout;
8397 ipr_cmd->done = ipr_reset_ioa_job;
8398 add_timer(&ipr_cmd->timer);
8400 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8402 return IPR_RC_JOB_RETURN;
8406 * ipr_reset_enable_ioa - Enable the IOA following a reset.
8407 * @ipr_cmd: ipr command struct
8409 * This function reinitializes some control blocks and
8410 * enables destructive diagnostics on the adapter.
8415 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
8417 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8418 volatile u32 int_reg;
8419 volatile u64 maskval;
8423 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8424 ipr_init_ioa_mem(ioa_cfg);
8426 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
8427 spin_lock(&ioa_cfg->hrrq[i]._lock);
8428 ioa_cfg->hrrq[i].allow_interrupts = 1;
8429 spin_unlock(&ioa_cfg->hrrq[i]._lock);
8432 if (ioa_cfg->sis64) {
8433 /* Set the adapter to the correct endian mode. */
8434 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8435 int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8438 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8440 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8441 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
8442 ioa_cfg->regs.clr_interrupt_mask_reg32);
8443 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8444 return IPR_RC_JOB_CONTINUE;
8447 /* Enable destructive diagnostics on IOA */
8448 writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
8450 if (ioa_cfg->sis64) {
8451 maskval = IPR_PCII_IPL_STAGE_CHANGE;
8452 maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
8453 writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
8455 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
8457 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8459 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
8461 if (ioa_cfg->sis64) {
8462 ipr_cmd->job_step = ipr_reset_next_stage;
8463 return IPR_RC_JOB_CONTINUE;
8466 ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
8467 ipr_cmd->timer.function = ipr_oper_timeout;
8468 ipr_cmd->done = ipr_reset_ioa_job;
8469 add_timer(&ipr_cmd->timer);
8470 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8473 return IPR_RC_JOB_RETURN;
8477 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8478 * @ipr_cmd: ipr command struct
8480 * This function is invoked when an adapter dump has run out
8481 * of processing time.
8484 * IPR_RC_JOB_CONTINUE
8486 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
8488 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8490 if (ioa_cfg->sdt_state == GET_DUMP)
8491 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8492 else if (ioa_cfg->sdt_state == READ_DUMP)
8493 ioa_cfg->sdt_state = ABORT_DUMP;
8495 ioa_cfg->dump_timeout = 1;
8496 ipr_cmd->job_step = ipr_reset_alert;
8498 return IPR_RC_JOB_CONTINUE;
8502 * ipr_unit_check_no_data - Log a unit check/no data error log
8503 * @ioa_cfg: ioa config struct
8505 * Logs an error indicating the adapter unit checked, but for some
8506 * reason, we were unable to fetch the unit check buffer.
8511 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
8513 ioa_cfg->errors_logged++;
8514 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
8518 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8519 * @ioa_cfg: ioa config struct
8521 * Fetches the unit check buffer from the adapter by clocking the data
8522 * through the mailbox register.
8527 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
8529 unsigned long mailbox;
8530 struct ipr_hostrcb *hostrcb;
8531 struct ipr_uc_sdt sdt;
8535 mailbox = readl(ioa_cfg->ioa_mailbox);
8537 if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
8538 ipr_unit_check_no_data(ioa_cfg);
8542 memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
8543 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
8544 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
8546 if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
8547 ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
8548 (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
8549 ipr_unit_check_no_data(ioa_cfg);
8553 /* Find length of the first sdt entry (UC buffer) */
8554 if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
8555 length = be32_to_cpu(sdt.entry[0].end_token);
8557 length = (be32_to_cpu(sdt.entry[0].end_token) -
8558 be32_to_cpu(sdt.entry[0].start_token)) &
8559 IPR_FMT2_MBX_ADDR_MASK;
8561 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
8562 struct ipr_hostrcb, queue);
8563 list_del_init(&hostrcb->queue);
8564 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
8566 rc = ipr_get_ldump_data_section(ioa_cfg,
8567 be32_to_cpu(sdt.entry[0].start_token),
8568 (__be32 *)&hostrcb->hcam,
8569 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
8572 ipr_handle_log_data(ioa_cfg, hostrcb);
8573 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
8574 if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
8575 ioa_cfg->sdt_state == GET_DUMP)
8576 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8578 ipr_unit_check_no_data(ioa_cfg);
8580 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
8584 * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8585 * @ipr_cmd: ipr command struct
8587 * Description: This function will call to get the unit check buffer.
8592 static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
8594 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8597 ioa_cfg->ioa_unit_checked = 0;
8598 ipr_get_unit_check_buffer(ioa_cfg);
8599 ipr_cmd->job_step = ipr_reset_alert;
8600 ipr_reset_start_timer(ipr_cmd, 0);
8603 return IPR_RC_JOB_RETURN;
8606 static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd)
8608 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8612 if (ioa_cfg->sdt_state != GET_DUMP)
8613 return IPR_RC_JOB_RETURN;
8615 if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left ||
8616 (readl(ioa_cfg->regs.sense_interrupt_reg) &
8617 IPR_PCII_MAILBOX_STABLE)) {
8619 if (!ipr_cmd->u.time_left)
8620 dev_err(&ioa_cfg->pdev->dev,
8621 "Timed out waiting for Mailbox register.\n");
8623 ioa_cfg->sdt_state = READ_DUMP;
8624 ioa_cfg->dump_timeout = 0;
8626 ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
8628 ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
8629 ipr_cmd->job_step = ipr_reset_wait_for_dump;
8630 schedule_work(&ioa_cfg->work_q);
8633 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8634 ipr_reset_start_timer(ipr_cmd,
8635 IPR_CHECK_FOR_RESET_TIMEOUT);
8639 return IPR_RC_JOB_RETURN;
8643 * ipr_reset_restore_cfg_space - Restore PCI config space.
8644 * @ipr_cmd: ipr command struct
8646 * Description: This function restores the saved PCI config space of
8647 * the adapter, fails all outstanding ops back to the callers, and
8648 * fetches the dump/unit check if applicable to this reset.
8651 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8653 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
8655 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8659 ioa_cfg->pdev->state_saved = true;
8660 pci_restore_state(ioa_cfg->pdev);
8662 if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
8663 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8664 return IPR_RC_JOB_CONTINUE;
8667 ipr_fail_all_ops(ioa_cfg);
8669 if (ioa_cfg->sis64) {
8670 /* Set the adapter to the correct endian mode. */
8671 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8672 int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8675 if (ioa_cfg->ioa_unit_checked) {
8676 if (ioa_cfg->sis64) {
8677 ipr_cmd->job_step = ipr_reset_get_unit_check_job;
8678 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
8679 return IPR_RC_JOB_RETURN;
8681 ioa_cfg->ioa_unit_checked = 0;
8682 ipr_get_unit_check_buffer(ioa_cfg);
8683 ipr_cmd->job_step = ipr_reset_alert;
8684 ipr_reset_start_timer(ipr_cmd, 0);
8685 return IPR_RC_JOB_RETURN;
8689 if (ioa_cfg->in_ioa_bringdown) {
8690 ipr_cmd->job_step = ipr_ioa_bringdown_done;
8691 } else if (ioa_cfg->sdt_state == GET_DUMP) {
8692 ipr_cmd->job_step = ipr_dump_mailbox_wait;
8693 ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX;
8695 ipr_cmd->job_step = ipr_reset_enable_ioa;
8699 return IPR_RC_JOB_CONTINUE;
8703 * ipr_reset_bist_done - BIST has completed on the adapter.
8704 * @ipr_cmd: ipr command struct
8706 * Description: Unblock config space and resume the reset process.
8709 * IPR_RC_JOB_CONTINUE
8711 static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
8713 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8716 if (ioa_cfg->cfg_locked)
8717 pci_cfg_access_unlock(ioa_cfg->pdev);
8718 ioa_cfg->cfg_locked = 0;
8719 ipr_cmd->job_step = ipr_reset_restore_cfg_space;
8721 return IPR_RC_JOB_CONTINUE;
8725 * ipr_reset_start_bist - Run BIST on the adapter.
8726 * @ipr_cmd: ipr command struct
8728 * Description: This function runs BIST on the adapter, then delays 2 seconds.
8731 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8733 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
8735 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8736 int rc = PCIBIOS_SUCCESSFUL;
8739 if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO)
8740 writel(IPR_UPROCI_SIS64_START_BIST,
8741 ioa_cfg->regs.set_uproc_interrupt_reg32);
8743 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
8745 if (rc == PCIBIOS_SUCCESSFUL) {
8746 ipr_cmd->job_step = ipr_reset_bist_done;
8747 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8748 rc = IPR_RC_JOB_RETURN;
8750 if (ioa_cfg->cfg_locked)
8751 pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev);
8752 ioa_cfg->cfg_locked = 0;
8753 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8754 rc = IPR_RC_JOB_CONTINUE;
8762 * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8763 * @ipr_cmd: ipr command struct
8765 * Description: This clears PCI reset to the adapter and delays two seconds.
8770 static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
8773 ipr_cmd->job_step = ipr_reset_bist_done;
8774 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8776 return IPR_RC_JOB_RETURN;
8780 * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8781 * @work: work struct
8783 * Description: This pulses warm reset to a slot.
8786 static void ipr_reset_reset_work(struct work_struct *work)
8788 struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work);
8789 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8790 struct pci_dev *pdev = ioa_cfg->pdev;
8791 unsigned long lock_flags = 0;
8794 pci_set_pcie_reset_state(pdev, pcie_warm_reset);
8795 msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT));
8796 pci_set_pcie_reset_state(pdev, pcie_deassert_reset);
8798 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8799 if (ioa_cfg->reset_cmd == ipr_cmd)
8800 ipr_reset_ioa_job(ipr_cmd);
8801 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8806 * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8807 * @ipr_cmd: ipr command struct
8809 * Description: This asserts PCI reset to the adapter.
8814 static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
8816 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8819 INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work);
8820 queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work);
8821 ipr_cmd->job_step = ipr_reset_slot_reset_done;
8823 return IPR_RC_JOB_RETURN;
8827 * ipr_reset_block_config_access_wait - Wait for permission to block config access
8828 * @ipr_cmd: ipr command struct
8830 * Description: This attempts to block config access to the IOA.
8833 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8835 static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd)
8837 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8838 int rc = IPR_RC_JOB_CONTINUE;
8840 if (pci_cfg_access_trylock(ioa_cfg->pdev)) {
8841 ioa_cfg->cfg_locked = 1;
8842 ipr_cmd->job_step = ioa_cfg->reset;
8844 if (ipr_cmd->u.time_left) {
8845 rc = IPR_RC_JOB_RETURN;
8846 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8847 ipr_reset_start_timer(ipr_cmd,
8848 IPR_CHECK_FOR_RESET_TIMEOUT);
8850 ipr_cmd->job_step = ioa_cfg->reset;
8851 dev_err(&ioa_cfg->pdev->dev,
8852 "Timed out waiting to lock config access. Resetting anyway.\n");
8860 * ipr_reset_block_config_access - Block config access to the IOA
8861 * @ipr_cmd: ipr command struct
8863 * Description: This attempts to block config access to the IOA
8866 * IPR_RC_JOB_CONTINUE
8868 static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd)
8870 ipr_cmd->ioa_cfg->cfg_locked = 0;
8871 ipr_cmd->job_step = ipr_reset_block_config_access_wait;
8872 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8873 return IPR_RC_JOB_CONTINUE;
8877 * ipr_reset_allowed - Query whether or not IOA can be reset
8878 * @ioa_cfg: ioa config struct
8881 * 0 if reset not allowed / non-zero if reset is allowed
8883 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
8885 volatile u32 temp_reg;
8887 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
8888 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
8892 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8893 * @ipr_cmd: ipr command struct
8895 * Description: This function waits for adapter permission to run BIST,
8896 * then runs BIST. If the adapter does not give permission after a
8897 * reasonable time, we will reset the adapter anyway. The impact of
8898 * resetting the adapter without warning the adapter is the risk of
8899 * losing the persistent error log on the adapter. If the adapter is
8900 * reset while it is writing to the flash on the adapter, the flash
8901 * segment will have bad ECC and be zeroed.
8904 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8906 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
8908 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8909 int rc = IPR_RC_JOB_RETURN;
8911 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
8912 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8913 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8915 ipr_cmd->job_step = ipr_reset_block_config_access;
8916 rc = IPR_RC_JOB_CONTINUE;
8923 * ipr_reset_alert - Alert the adapter of a pending reset
8924 * @ipr_cmd: ipr command struct
8926 * Description: This function alerts the adapter that it will be reset.
8927 * If memory space is not currently enabled, proceed directly
8928 * to running BIST on the adapter. The timer must always be started
8929 * so we guarantee we do not run BIST from ipr_isr.
8934 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
8936 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8941 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
8943 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
8944 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
8945 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
8946 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
8948 ipr_cmd->job_step = ipr_reset_block_config_access;
8951 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8952 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8955 return IPR_RC_JOB_RETURN;
8959 * ipr_reset_quiesce_done - Complete IOA disconnect
8960 * @ipr_cmd: ipr command struct
8962 * Description: Freeze the adapter to complete quiesce processing
8965 * IPR_RC_JOB_CONTINUE
8967 static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd)
8969 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8972 ipr_cmd->job_step = ipr_ioa_bringdown_done;
8973 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
8975 return IPR_RC_JOB_CONTINUE;
8979 * ipr_reset_cancel_hcam_done - Check for outstanding commands
8980 * @ipr_cmd: ipr command struct
8982 * Description: Ensure nothing is outstanding to the IOA and
8983 * proceed with IOA disconnect. Otherwise reset the IOA.
8986 * IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
8988 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd)
8990 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8991 struct ipr_cmnd *loop_cmd;
8992 struct ipr_hrr_queue *hrrq;
8993 int rc = IPR_RC_JOB_CONTINUE;
8997 ipr_cmd->job_step = ipr_reset_quiesce_done;
8999 for_each_hrrq(hrrq, ioa_cfg) {
9000 spin_lock(&hrrq->_lock);
9001 list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) {
9003 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9004 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9005 rc = IPR_RC_JOB_RETURN;
9008 spin_unlock(&hrrq->_lock);
9019 * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
9020 * @ipr_cmd: ipr command struct
9022 * Description: Cancel any oustanding HCAMs to the IOA.
9025 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9027 static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd)
9029 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9030 int rc = IPR_RC_JOB_CONTINUE;
9031 struct ipr_cmd_pkt *cmd_pkt;
9032 struct ipr_cmnd *hcam_cmd;
9033 struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ];
9036 ipr_cmd->job_step = ipr_reset_cancel_hcam_done;
9038 if (!hrrq->ioa_is_dead) {
9039 if (!list_empty(&ioa_cfg->hostrcb_pending_q)) {
9040 list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) {
9041 if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC)
9044 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9045 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9046 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
9047 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
9048 cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST;
9049 cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB;
9050 cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff;
9051 cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff;
9052 cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff;
9053 cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff;
9054 cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff;
9055 cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff;
9056 cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff;
9057 cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff;
9059 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9060 IPR_CANCEL_TIMEOUT);
9062 rc = IPR_RC_JOB_RETURN;
9063 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9068 ipr_cmd->job_step = ipr_reset_alert;
9075 * ipr_reset_ucode_download_done - Microcode download completion
9076 * @ipr_cmd: ipr command struct
9078 * Description: This function unmaps the microcode download buffer.
9081 * IPR_RC_JOB_CONTINUE
9083 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
9085 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9086 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9088 dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
9089 sglist->num_sg, DMA_TO_DEVICE);
9091 ipr_cmd->job_step = ipr_reset_alert;
9092 return IPR_RC_JOB_CONTINUE;
9096 * ipr_reset_ucode_download - Download microcode to the adapter
9097 * @ipr_cmd: ipr command struct
9099 * Description: This function checks to see if it there is microcode
9100 * to download to the adapter. If there is, a download is performed.
9103 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9105 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
9107 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9108 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9111 ipr_cmd->job_step = ipr_reset_alert;
9114 return IPR_RC_JOB_CONTINUE;
9116 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9117 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
9118 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
9119 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
9120 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
9121 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
9122 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
9125 ipr_build_ucode_ioadl64(ipr_cmd, sglist);
9127 ipr_build_ucode_ioadl(ipr_cmd, sglist);
9128 ipr_cmd->job_step = ipr_reset_ucode_download_done;
9130 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9131 IPR_WRITE_BUFFER_TIMEOUT);
9134 return IPR_RC_JOB_RETURN;
9138 * ipr_reset_shutdown_ioa - Shutdown the adapter
9139 * @ipr_cmd: ipr command struct
9141 * Description: This function issues an adapter shutdown of the
9142 * specified type to the specified adapter as part of the
9143 * adapter reset job.
9146 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9148 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
9150 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9151 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
9152 unsigned long timeout;
9153 int rc = IPR_RC_JOB_CONTINUE;
9156 if (shutdown_type == IPR_SHUTDOWN_QUIESCE)
9157 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9158 else if (shutdown_type != IPR_SHUTDOWN_NONE &&
9159 !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
9160 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9161 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9162 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
9163 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
9165 if (shutdown_type == IPR_SHUTDOWN_NORMAL)
9166 timeout = IPR_SHUTDOWN_TIMEOUT;
9167 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
9168 timeout = IPR_INTERNAL_TIMEOUT;
9169 else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
9170 timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
9172 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
9174 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
9176 rc = IPR_RC_JOB_RETURN;
9177 ipr_cmd->job_step = ipr_reset_ucode_download;
9179 ipr_cmd->job_step = ipr_reset_alert;
9186 * ipr_reset_ioa_job - Adapter reset job
9187 * @ipr_cmd: ipr command struct
9189 * Description: This function is the job router for the adapter reset job.
9194 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
9197 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9200 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
9202 if (ioa_cfg->reset_cmd != ipr_cmd) {
9204 * We are doing nested adapter resets and this is
9205 * not the current reset job.
9207 list_add_tail(&ipr_cmd->queue,
9208 &ipr_cmd->hrrq->hrrq_free_q);
9212 if (IPR_IOASC_SENSE_KEY(ioasc)) {
9213 rc = ipr_cmd->job_step_failed(ipr_cmd);
9214 if (rc == IPR_RC_JOB_RETURN)
9218 ipr_reinit_ipr_cmnd(ipr_cmd);
9219 ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
9220 rc = ipr_cmd->job_step(ipr_cmd);
9221 } while (rc == IPR_RC_JOB_CONTINUE);
9225 * _ipr_initiate_ioa_reset - Initiate an adapter reset
9226 * @ioa_cfg: ioa config struct
9227 * @job_step: first job step of reset job
9228 * @shutdown_type: shutdown type
9230 * Description: This function will initiate the reset of the given adapter
9231 * starting at the selected job step.
9232 * If the caller needs to wait on the completion of the reset,
9233 * the caller must sleep on the reset_wait_q.
9238 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9239 int (*job_step) (struct ipr_cmnd *),
9240 enum ipr_shutdown_type shutdown_type)
9242 struct ipr_cmnd *ipr_cmd;
9245 ioa_cfg->in_reset_reload = 1;
9246 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9247 spin_lock(&ioa_cfg->hrrq[i]._lock);
9248 ioa_cfg->hrrq[i].allow_cmds = 0;
9249 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9252 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9253 ioa_cfg->scsi_unblock = 0;
9254 ioa_cfg->scsi_blocked = 1;
9255 scsi_block_requests(ioa_cfg->host);
9258 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
9259 ioa_cfg->reset_cmd = ipr_cmd;
9260 ipr_cmd->job_step = job_step;
9261 ipr_cmd->u.shutdown_type = shutdown_type;
9263 ipr_reset_ioa_job(ipr_cmd);
9267 * ipr_initiate_ioa_reset - Initiate an adapter reset
9268 * @ioa_cfg: ioa config struct
9269 * @shutdown_type: shutdown type
9271 * Description: This function will initiate the reset of the given adapter.
9272 * If the caller needs to wait on the completion of the reset,
9273 * the caller must sleep on the reset_wait_q.
9278 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9279 enum ipr_shutdown_type shutdown_type)
9283 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
9286 if (ioa_cfg->in_reset_reload) {
9287 if (ioa_cfg->sdt_state == GET_DUMP)
9288 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
9289 else if (ioa_cfg->sdt_state == READ_DUMP)
9290 ioa_cfg->sdt_state = ABORT_DUMP;
9293 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
9294 dev_err(&ioa_cfg->pdev->dev,
9295 "IOA taken offline - error recovery failed\n");
9297 ioa_cfg->reset_retries = 0;
9298 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9299 spin_lock(&ioa_cfg->hrrq[i]._lock);
9300 ioa_cfg->hrrq[i].ioa_is_dead = 1;
9301 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9305 if (ioa_cfg->in_ioa_bringdown) {
9306 ioa_cfg->reset_cmd = NULL;
9307 ioa_cfg->in_reset_reload = 0;
9308 ipr_fail_all_ops(ioa_cfg);
9309 wake_up_all(&ioa_cfg->reset_wait_q);
9311 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9312 ioa_cfg->scsi_unblock = 1;
9313 schedule_work(&ioa_cfg->work_q);
9317 ioa_cfg->in_ioa_bringdown = 1;
9318 shutdown_type = IPR_SHUTDOWN_NONE;
9322 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
9327 * ipr_reset_freeze - Hold off all I/O activity
9328 * @ipr_cmd: ipr command struct
9330 * Description: If the PCI slot is frozen, hold off all I/O
9331 * activity; then, as soon as the slot is available again,
9332 * initiate an adapter reset.
9334 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
9336 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9339 /* Disallow new interrupts, avoid loop */
9340 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9341 spin_lock(&ioa_cfg->hrrq[i]._lock);
9342 ioa_cfg->hrrq[i].allow_interrupts = 0;
9343 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9346 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
9347 ipr_cmd->done = ipr_reset_ioa_job;
9348 return IPR_RC_JOB_RETURN;
9352 * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9353 * @pdev: PCI device struct
9355 * Description: This routine is called to tell us that the MMIO
9356 * access to the IOA has been restored
9358 static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev)
9360 unsigned long flags = 0;
9361 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9363 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9364 if (!ioa_cfg->probe_done)
9365 pci_save_state(pdev);
9366 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9367 return PCI_ERS_RESULT_NEED_RESET;
9371 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9372 * @pdev: PCI device struct
9374 * Description: This routine is called to tell us that the PCI bus
9375 * is down. Can't do anything here, except put the device driver
9376 * into a holding pattern, waiting for the PCI bus to come back.
9378 static void ipr_pci_frozen(struct pci_dev *pdev)
9380 unsigned long flags = 0;
9381 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9383 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9384 if (ioa_cfg->probe_done)
9385 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
9386 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9390 * ipr_pci_slot_reset - Called when PCI slot has been reset.
9391 * @pdev: PCI device struct
9393 * Description: This routine is called by the pci error recovery
9394 * code after the PCI slot has been reset, just before we
9395 * should resume normal operations.
9397 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
9399 unsigned long flags = 0;
9400 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9402 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9403 if (ioa_cfg->probe_done) {
9404 if (ioa_cfg->needs_warm_reset)
9405 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9407 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
9410 wake_up_all(&ioa_cfg->eeh_wait_q);
9411 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9412 return PCI_ERS_RESULT_RECOVERED;
9416 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9417 * @pdev: PCI device struct
9419 * Description: This routine is called when the PCI bus has
9420 * permanently failed.
9422 static void ipr_pci_perm_failure(struct pci_dev *pdev)
9424 unsigned long flags = 0;
9425 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9428 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9429 if (ioa_cfg->probe_done) {
9430 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
9431 ioa_cfg->sdt_state = ABORT_DUMP;
9432 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
9433 ioa_cfg->in_ioa_bringdown = 1;
9434 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9435 spin_lock(&ioa_cfg->hrrq[i]._lock);
9436 ioa_cfg->hrrq[i].allow_cmds = 0;
9437 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9440 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9442 wake_up_all(&ioa_cfg->eeh_wait_q);
9443 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9447 * ipr_pci_error_detected - Called when a PCI error is detected.
9448 * @pdev: PCI device struct
9449 * @state: PCI channel state
9451 * Description: Called when a PCI error is detected.
9454 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9456 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
9457 pci_channel_state_t state)
9460 case pci_channel_io_frozen:
9461 ipr_pci_frozen(pdev);
9462 return PCI_ERS_RESULT_CAN_RECOVER;
9463 case pci_channel_io_perm_failure:
9464 ipr_pci_perm_failure(pdev);
9465 return PCI_ERS_RESULT_DISCONNECT;
9470 return PCI_ERS_RESULT_NEED_RESET;
9474 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9475 * @ioa_cfg: ioa cfg struct
9477 * Description: This is the second phase of adapter initialization
9478 * This function takes care of initilizing the adapter to the point
9479 * where it can accept new commands.
9482 * 0 on success / -EIO on failure
9484 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
9487 unsigned long host_lock_flags = 0;
9490 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
9491 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
9492 ioa_cfg->probe_done = 1;
9493 if (ioa_cfg->needs_hard_reset) {
9494 ioa_cfg->needs_hard_reset = 0;
9495 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9497 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
9499 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
9506 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9507 * @ioa_cfg: ioa config struct
9512 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9516 if (ioa_cfg->ipr_cmnd_list) {
9517 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9518 if (ioa_cfg->ipr_cmnd_list[i])
9519 dma_pool_free(ioa_cfg->ipr_cmd_pool,
9520 ioa_cfg->ipr_cmnd_list[i],
9521 ioa_cfg->ipr_cmnd_list_dma[i]);
9523 ioa_cfg->ipr_cmnd_list[i] = NULL;
9527 if (ioa_cfg->ipr_cmd_pool)
9528 dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
9530 kfree(ioa_cfg->ipr_cmnd_list);
9531 kfree(ioa_cfg->ipr_cmnd_list_dma);
9532 ioa_cfg->ipr_cmnd_list = NULL;
9533 ioa_cfg->ipr_cmnd_list_dma = NULL;
9534 ioa_cfg->ipr_cmd_pool = NULL;
9538 * ipr_free_mem - Frees memory allocated for an adapter
9539 * @ioa_cfg: ioa cfg struct
9544 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
9548 kfree(ioa_cfg->res_entries);
9549 dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
9550 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9551 ipr_free_cmd_blks(ioa_cfg);
9553 for (i = 0; i < ioa_cfg->hrrq_num; i++)
9554 dma_free_coherent(&ioa_cfg->pdev->dev,
9555 sizeof(u32) * ioa_cfg->hrrq[i].size,
9556 ioa_cfg->hrrq[i].host_rrq,
9557 ioa_cfg->hrrq[i].host_rrq_dma);
9559 dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
9560 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9562 for (i = 0; i < IPR_MAX_HCAMS; i++) {
9563 dma_free_coherent(&ioa_cfg->pdev->dev,
9564 sizeof(struct ipr_hostrcb),
9565 ioa_cfg->hostrcb[i],
9566 ioa_cfg->hostrcb_dma[i]);
9569 ipr_free_dump(ioa_cfg);
9570 kfree(ioa_cfg->trace);
9574 * ipr_free_irqs - Free all allocated IRQs for the adapter.
9575 * @ioa_cfg: ipr cfg struct
9577 * This function frees all allocated IRQs for the
9578 * specified adapter.
9583 static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg)
9585 struct pci_dev *pdev = ioa_cfg->pdev;
9588 for (i = 0; i < ioa_cfg->nvectors; i++)
9589 free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]);
9590 pci_free_irq_vectors(pdev);
9594 * ipr_free_all_resources - Free all allocated resources for an adapter.
9595 * @ipr_cmd: ipr command struct
9597 * This function frees all allocated resources for the
9598 * specified adapter.
9603 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
9605 struct pci_dev *pdev = ioa_cfg->pdev;
9608 ipr_free_irqs(ioa_cfg);
9609 if (ioa_cfg->reset_work_q)
9610 destroy_workqueue(ioa_cfg->reset_work_q);
9611 iounmap(ioa_cfg->hdw_dma_regs);
9612 pci_release_regions(pdev);
9613 ipr_free_mem(ioa_cfg);
9614 scsi_host_put(ioa_cfg->host);
9615 pci_disable_device(pdev);
9620 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9621 * @ioa_cfg: ioa config struct
9624 * 0 on success / -ENOMEM on allocation failure
9626 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9628 struct ipr_cmnd *ipr_cmd;
9629 struct ipr_ioarcb *ioarcb;
9630 dma_addr_t dma_addr;
9631 int i, entries_each_hrrq, hrrq_id = 0;
9633 ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
9634 sizeof(struct ipr_cmnd), 512, 0);
9636 if (!ioa_cfg->ipr_cmd_pool)
9639 ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL);
9640 ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL);
9642 if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
9643 ipr_free_cmd_blks(ioa_cfg);
9647 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9648 if (ioa_cfg->hrrq_num > 1) {
9650 entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS;
9651 ioa_cfg->hrrq[i].min_cmd_id = 0;
9652 ioa_cfg->hrrq[i].max_cmd_id =
9653 (entries_each_hrrq - 1);
9656 IPR_NUM_BASE_CMD_BLKS/
9657 (ioa_cfg->hrrq_num - 1);
9658 ioa_cfg->hrrq[i].min_cmd_id =
9659 IPR_NUM_INTERNAL_CMD_BLKS +
9660 (i - 1) * entries_each_hrrq;
9661 ioa_cfg->hrrq[i].max_cmd_id =
9662 (IPR_NUM_INTERNAL_CMD_BLKS +
9663 i * entries_each_hrrq - 1);
9666 entries_each_hrrq = IPR_NUM_CMD_BLKS;
9667 ioa_cfg->hrrq[i].min_cmd_id = 0;
9668 ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1);
9670 ioa_cfg->hrrq[i].size = entries_each_hrrq;
9673 BUG_ON(ioa_cfg->hrrq_num == 0);
9675 i = IPR_NUM_CMD_BLKS -
9676 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1;
9678 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i;
9679 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i;
9682 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9683 ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool,
9684 GFP_KERNEL, &dma_addr);
9687 ipr_free_cmd_blks(ioa_cfg);
9691 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
9692 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
9694 ioarcb = &ipr_cmd->ioarcb;
9695 ipr_cmd->dma_addr = dma_addr;
9697 ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
9699 ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
9701 ioarcb->host_response_handle = cpu_to_be32(i << 2);
9702 if (ioa_cfg->sis64) {
9703 ioarcb->u.sis64_addr_data.data_ioadl_addr =
9704 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
9705 ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
9706 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
9708 ioarcb->write_ioadl_addr =
9709 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
9710 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
9711 ioarcb->ioasa_host_pci_addr =
9712 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
9714 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
9715 ipr_cmd->cmd_index = i;
9716 ipr_cmd->ioa_cfg = ioa_cfg;
9717 ipr_cmd->sense_buffer_dma = dma_addr +
9718 offsetof(struct ipr_cmnd, sense_buffer);
9720 ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id;
9721 ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id];
9722 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9723 if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id)
9731 * ipr_alloc_mem - Allocate memory for an adapter
9732 * @ioa_cfg: ioa config struct
9735 * 0 on success / non-zero for error
9737 static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
9739 struct pci_dev *pdev = ioa_cfg->pdev;
9740 int i, rc = -ENOMEM;
9743 ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported,
9744 sizeof(struct ipr_resource_entry),
9747 if (!ioa_cfg->res_entries)
9750 for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
9751 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
9752 ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
9755 ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
9756 sizeof(struct ipr_misc_cbs),
9757 &ioa_cfg->vpd_cbs_dma,
9760 if (!ioa_cfg->vpd_cbs)
9761 goto out_free_res_entries;
9763 if (ipr_alloc_cmd_blks(ioa_cfg))
9764 goto out_free_vpd_cbs;
9766 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9767 ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
9768 sizeof(u32) * ioa_cfg->hrrq[i].size,
9769 &ioa_cfg->hrrq[i].host_rrq_dma,
9772 if (!ioa_cfg->hrrq[i].host_rrq) {
9774 dma_free_coherent(&pdev->dev,
9775 sizeof(u32) * ioa_cfg->hrrq[i].size,
9776 ioa_cfg->hrrq[i].host_rrq,
9777 ioa_cfg->hrrq[i].host_rrq_dma);
9778 goto out_ipr_free_cmd_blocks;
9780 ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
9783 ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
9784 ioa_cfg->cfg_table_size,
9785 &ioa_cfg->cfg_table_dma,
9788 if (!ioa_cfg->u.cfg_table)
9789 goto out_free_host_rrq;
9791 for (i = 0; i < IPR_MAX_HCAMS; i++) {
9792 ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
9793 sizeof(struct ipr_hostrcb),
9794 &ioa_cfg->hostrcb_dma[i],
9797 if (!ioa_cfg->hostrcb[i])
9798 goto out_free_hostrcb_dma;
9800 ioa_cfg->hostrcb[i]->hostrcb_dma =
9801 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
9802 ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
9803 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
9806 ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES,
9807 sizeof(struct ipr_trace_entry),
9810 if (!ioa_cfg->trace)
9811 goto out_free_hostrcb_dma;
9818 out_free_hostrcb_dma:
9820 dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
9821 ioa_cfg->hostrcb[i],
9822 ioa_cfg->hostrcb_dma[i]);
9824 dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
9825 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9827 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9828 dma_free_coherent(&pdev->dev,
9829 sizeof(u32) * ioa_cfg->hrrq[i].size,
9830 ioa_cfg->hrrq[i].host_rrq,
9831 ioa_cfg->hrrq[i].host_rrq_dma);
9833 out_ipr_free_cmd_blocks:
9834 ipr_free_cmd_blks(ioa_cfg);
9836 dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
9837 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9838 out_free_res_entries:
9839 kfree(ioa_cfg->res_entries);
9844 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9845 * @ioa_cfg: ioa config struct
9850 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
9854 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
9855 ioa_cfg->bus_attr[i].bus = i;
9856 ioa_cfg->bus_attr[i].qas_enabled = 0;
9857 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
9858 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
9859 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
9861 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
9866 * ipr_init_regs - Initialize IOA registers
9867 * @ioa_cfg: ioa config struct
9872 static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg)
9874 const struct ipr_interrupt_offsets *p;
9875 struct ipr_interrupts *t;
9878 p = &ioa_cfg->chip_cfg->regs;
9880 base = ioa_cfg->hdw_dma_regs;
9882 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
9883 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
9884 t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
9885 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
9886 t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
9887 t->clr_interrupt_reg = base + p->clr_interrupt_reg;
9888 t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
9889 t->sense_interrupt_reg = base + p->sense_interrupt_reg;
9890 t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
9891 t->ioarrin_reg = base + p->ioarrin_reg;
9892 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
9893 t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
9894 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
9895 t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
9896 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
9897 t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
9899 if (ioa_cfg->sis64) {
9900 t->init_feedback_reg = base + p->init_feedback_reg;
9901 t->dump_addr_reg = base + p->dump_addr_reg;
9902 t->dump_data_reg = base + p->dump_data_reg;
9903 t->endian_swap_reg = base + p->endian_swap_reg;
9908 * ipr_init_ioa_cfg - Initialize IOA config struct
9909 * @ioa_cfg: ioa config struct
9910 * @host: scsi host struct
9911 * @pdev: PCI dev struct
9916 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
9917 struct Scsi_Host *host, struct pci_dev *pdev)
9921 ioa_cfg->host = host;
9922 ioa_cfg->pdev = pdev;
9923 ioa_cfg->log_level = ipr_log_level;
9924 ioa_cfg->doorbell = IPR_DOORBELL;
9925 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
9926 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
9927 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
9928 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
9929 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
9930 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
9932 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
9933 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
9934 INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q);
9935 INIT_LIST_HEAD(&ioa_cfg->free_res_q);
9936 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
9937 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
9938 init_waitqueue_head(&ioa_cfg->reset_wait_q);
9939 init_waitqueue_head(&ioa_cfg->msi_wait_q);
9940 init_waitqueue_head(&ioa_cfg->eeh_wait_q);
9941 ioa_cfg->sdt_state = INACTIVE;
9943 ipr_initialize_bus_attr(ioa_cfg);
9944 ioa_cfg->max_devs_supported = ipr_max_devs;
9946 if (ioa_cfg->sis64) {
9947 host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
9948 host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
9949 if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
9950 ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
9951 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
9952 + ((sizeof(struct ipr_config_table_entry64)
9953 * ioa_cfg->max_devs_supported)));
9955 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
9956 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
9957 if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
9958 ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
9959 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
9960 + ((sizeof(struct ipr_config_table_entry)
9961 * ioa_cfg->max_devs_supported)));
9964 host->max_channel = IPR_VSET_BUS;
9965 host->unique_id = host->host_no;
9966 host->max_cmd_len = IPR_MAX_CDB_LEN;
9967 host->can_queue = ioa_cfg->max_cmds;
9968 pci_set_drvdata(pdev, ioa_cfg);
9970 for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) {
9971 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q);
9972 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q);
9973 spin_lock_init(&ioa_cfg->hrrq[i]._lock);
9975 ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock;
9977 ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock;
9982 * ipr_get_chip_info - Find adapter chip information
9983 * @dev_id: PCI device id struct
9986 * ptr to chip information on success / NULL on failure
9988 static const struct ipr_chip_t *
9989 ipr_get_chip_info(const struct pci_device_id *dev_id)
9993 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
9994 if (ipr_chip[i].vendor == dev_id->vendor &&
9995 ipr_chip[i].device == dev_id->device)
9996 return &ipr_chip[i];
10001 * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
10002 * during probe time
10003 * @ioa_cfg: ioa config struct
10008 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg)
10010 struct pci_dev *pdev = ioa_cfg->pdev;
10012 if (pci_channel_offline(pdev)) {
10013 wait_event_timeout(ioa_cfg->eeh_wait_q,
10014 !pci_channel_offline(pdev),
10015 IPR_PCI_ERROR_RECOVERY_TIMEOUT);
10016 pci_restore_state(pdev);
10020 static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg)
10022 int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1;
10024 for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) {
10025 snprintf(ioa_cfg->vectors_info[vec_idx].desc, n,
10026 "host%d-%d", ioa_cfg->host->host_no, vec_idx);
10027 ioa_cfg->vectors_info[vec_idx].
10028 desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0;
10032 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg,
10033 struct pci_dev *pdev)
10037 for (i = 1; i < ioa_cfg->nvectors; i++) {
10038 rc = request_irq(pci_irq_vector(pdev, i),
10041 ioa_cfg->vectors_info[i].desc,
10042 &ioa_cfg->hrrq[i]);
10045 free_irq(pci_irq_vector(pdev, i),
10046 &ioa_cfg->hrrq[i]);
10054 * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
10055 * @pdev: PCI device struct
10057 * Description: Simply set the msi_received flag to 1 indicating that
10058 * Message Signaled Interrupts are supported.
10061 * 0 on success / non-zero on failure
10063 static irqreturn_t ipr_test_intr(int irq, void *devp)
10065 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
10066 unsigned long lock_flags = 0;
10067 irqreturn_t rc = IRQ_HANDLED;
10069 dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq);
10070 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10072 ioa_cfg->msi_received = 1;
10073 wake_up(&ioa_cfg->msi_wait_q);
10075 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10080 * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
10081 * @pdev: PCI device struct
10083 * Description: This routine sets up and initiates a test interrupt to determine
10084 * if the interrupt is received via the ipr_test_intr() service routine.
10085 * If the tests fails, the driver will fall back to LSI.
10088 * 0 on success / non-zero on failure
10090 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
10093 volatile u32 int_reg;
10094 unsigned long lock_flags = 0;
10095 int irq = pci_irq_vector(pdev, 0);
10099 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10100 init_waitqueue_head(&ioa_cfg->msi_wait_q);
10101 ioa_cfg->msi_received = 0;
10102 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10103 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
10104 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
10105 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10107 rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
10109 dev_err(&pdev->dev, "Can not assign irq %d\n", irq);
10111 } else if (ipr_debug)
10112 dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
10114 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
10115 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
10116 wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
10117 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10118 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10120 if (!ioa_cfg->msi_received) {
10121 /* MSI test failed */
10122 dev_info(&pdev->dev, "MSI test failed. Falling back to LSI.\n");
10124 } else if (ipr_debug)
10125 dev_info(&pdev->dev, "MSI test succeeded.\n");
10127 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10129 free_irq(irq, ioa_cfg);
10136 /* ipr_probe_ioa - Allocates memory and does first stage of initialization
10137 * @pdev: PCI device struct
10138 * @dev_id: PCI device id struct
10141 * 0 on success / non-zero on failure
10143 static int ipr_probe_ioa(struct pci_dev *pdev,
10144 const struct pci_device_id *dev_id)
10146 struct ipr_ioa_cfg *ioa_cfg;
10147 struct Scsi_Host *host;
10148 unsigned long ipr_regs_pci;
10149 void __iomem *ipr_regs;
10150 int rc = PCIBIOS_SUCCESSFUL;
10151 volatile u32 mask, uproc, interrupts;
10152 unsigned long lock_flags, driver_lock_flags;
10153 unsigned int irq_flag;
10157 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
10158 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
10161 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
10166 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
10167 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
10168 ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops);
10170 ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
10172 if (!ioa_cfg->ipr_chip) {
10173 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
10174 dev_id->vendor, dev_id->device);
10175 goto out_scsi_host_put;
10178 /* set SIS 32 or SIS 64 */
10179 ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
10180 ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
10181 ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr;
10182 ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds;
10184 if (ipr_transop_timeout)
10185 ioa_cfg->transop_timeout = ipr_transop_timeout;
10186 else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
10187 ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
10189 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
10191 ioa_cfg->revid = pdev->revision;
10193 ipr_init_ioa_cfg(ioa_cfg, host, pdev);
10195 ipr_regs_pci = pci_resource_start(pdev, 0);
10197 rc = pci_request_regions(pdev, IPR_NAME);
10199 dev_err(&pdev->dev,
10200 "Couldn't register memory range of registers\n");
10201 goto out_scsi_host_put;
10204 rc = pci_enable_device(pdev);
10206 if (rc || pci_channel_offline(pdev)) {
10207 if (pci_channel_offline(pdev)) {
10208 ipr_wait_for_pci_err_recovery(ioa_cfg);
10209 rc = pci_enable_device(pdev);
10213 dev_err(&pdev->dev, "Cannot enable adapter\n");
10214 ipr_wait_for_pci_err_recovery(ioa_cfg);
10215 goto out_release_regions;
10219 ipr_regs = pci_ioremap_bar(pdev, 0);
10222 dev_err(&pdev->dev,
10223 "Couldn't map memory range of registers\n");
10228 ioa_cfg->hdw_dma_regs = ipr_regs;
10229 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
10230 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
10232 ipr_init_regs(ioa_cfg);
10234 if (ioa_cfg->sis64) {
10235 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
10237 dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
10238 rc = dma_set_mask_and_coherent(&pdev->dev,
10242 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
10245 dev_err(&pdev->dev, "Failed to set DMA mask\n");
10246 goto cleanup_nomem;
10249 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
10250 ioa_cfg->chip_cfg->cache_line_size);
10252 if (rc != PCIBIOS_SUCCESSFUL) {
10253 dev_err(&pdev->dev, "Write of cache line size failed\n");
10254 ipr_wait_for_pci_err_recovery(ioa_cfg);
10256 goto cleanup_nomem;
10259 /* Issue MMIO read to ensure card is not in EEH */
10260 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
10261 ipr_wait_for_pci_err_recovery(ioa_cfg);
10263 if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) {
10264 dev_err(&pdev->dev, "The max number of MSIX is %d\n",
10265 IPR_MAX_MSIX_VECTORS);
10266 ipr_number_of_msix = IPR_MAX_MSIX_VECTORS;
10269 irq_flag = PCI_IRQ_LEGACY;
10270 if (ioa_cfg->ipr_chip->has_msi)
10271 irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX;
10272 rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag);
10274 ipr_wait_for_pci_err_recovery(ioa_cfg);
10275 goto cleanup_nomem;
10277 ioa_cfg->nvectors = rc;
10279 if (!pdev->msi_enabled && !pdev->msix_enabled)
10280 ioa_cfg->clear_isr = 1;
10282 pci_set_master(pdev);
10284 if (pci_channel_offline(pdev)) {
10285 ipr_wait_for_pci_err_recovery(ioa_cfg);
10286 pci_set_master(pdev);
10287 if (pci_channel_offline(pdev)) {
10289 goto out_msi_disable;
10293 if (pdev->msi_enabled || pdev->msix_enabled) {
10294 rc = ipr_test_msi(ioa_cfg, pdev);
10297 dev_info(&pdev->dev,
10298 "Request for %d MSI%ss succeeded.", ioa_cfg->nvectors,
10299 pdev->msix_enabled ? "-X" : "");
10302 ipr_wait_for_pci_err_recovery(ioa_cfg);
10303 pci_free_irq_vectors(pdev);
10305 ioa_cfg->nvectors = 1;
10306 ioa_cfg->clear_isr = 1;
10309 goto out_msi_disable;
10313 ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors,
10314 (unsigned int)num_online_cpus(),
10315 (unsigned int)IPR_MAX_HRRQ_NUM);
10317 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
10318 goto out_msi_disable;
10320 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
10321 goto out_msi_disable;
10323 rc = ipr_alloc_mem(ioa_cfg);
10325 dev_err(&pdev->dev,
10326 "Couldn't allocate enough memory for device driver!\n");
10327 goto out_msi_disable;
10330 /* Save away PCI config space for use following IOA reset */
10331 rc = pci_save_state(pdev);
10333 if (rc != PCIBIOS_SUCCESSFUL) {
10334 dev_err(&pdev->dev, "Failed to save PCI config space\n");
10336 goto cleanup_nolog;
10340 * If HRRQ updated interrupt is not masked, or reset alert is set,
10341 * the card is in an unknown state and needs a hard reset
10343 mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
10344 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
10345 uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
10346 if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
10347 ioa_cfg->needs_hard_reset = 1;
10348 if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices)
10349 ioa_cfg->needs_hard_reset = 1;
10350 if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
10351 ioa_cfg->ioa_unit_checked = 1;
10353 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10354 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10355 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10357 if (pdev->msi_enabled || pdev->msix_enabled) {
10358 name_msi_vectors(ioa_cfg);
10359 rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0,
10360 ioa_cfg->vectors_info[0].desc,
10361 &ioa_cfg->hrrq[0]);
10363 rc = ipr_request_other_msi_irqs(ioa_cfg, pdev);
10365 rc = request_irq(pdev->irq, ipr_isr,
10367 IPR_NAME, &ioa_cfg->hrrq[0]);
10370 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
10372 goto cleanup_nolog;
10375 if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
10376 (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
10377 ioa_cfg->needs_warm_reset = 1;
10378 ioa_cfg->reset = ipr_reset_slot_reset;
10380 ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d",
10381 WQ_MEM_RECLAIM, host->host_no);
10383 if (!ioa_cfg->reset_work_q) {
10384 dev_err(&pdev->dev, "Couldn't register reset workqueue\n");
10389 ioa_cfg->reset = ipr_reset_start_bist;
10391 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10392 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
10393 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10400 ipr_free_irqs(ioa_cfg);
10402 ipr_free_mem(ioa_cfg);
10404 ipr_wait_for_pci_err_recovery(ioa_cfg);
10405 pci_free_irq_vectors(pdev);
10409 pci_disable_device(pdev);
10410 out_release_regions:
10411 pci_release_regions(pdev);
10413 scsi_host_put(host);
10418 * ipr_initiate_ioa_bringdown - Bring down an adapter
10419 * @ioa_cfg: ioa config struct
10420 * @shutdown_type: shutdown type
10422 * Description: This function will initiate bringing down the adapter.
10423 * This consists of issuing an IOA shutdown to the adapter
10424 * to flush the cache, and running BIST.
10425 * If the caller needs to wait on the completion of the reset,
10426 * the caller must sleep on the reset_wait_q.
10431 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
10432 enum ipr_shutdown_type shutdown_type)
10435 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
10436 ioa_cfg->sdt_state = ABORT_DUMP;
10437 ioa_cfg->reset_retries = 0;
10438 ioa_cfg->in_ioa_bringdown = 1;
10439 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
10444 * __ipr_remove - Remove a single adapter
10445 * @pdev: pci device struct
10447 * Adapter hot plug remove entry point.
10452 static void __ipr_remove(struct pci_dev *pdev)
10454 unsigned long host_lock_flags = 0;
10455 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10457 unsigned long driver_lock_flags;
10460 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10461 while (ioa_cfg->in_reset_reload) {
10462 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10463 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10464 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10467 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
10468 spin_lock(&ioa_cfg->hrrq[i]._lock);
10469 ioa_cfg->hrrq[i].removing_ioa = 1;
10470 spin_unlock(&ioa_cfg->hrrq[i]._lock);
10473 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
10475 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10476 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10477 flush_work(&ioa_cfg->work_q);
10478 if (ioa_cfg->reset_work_q)
10479 flush_workqueue(ioa_cfg->reset_work_q);
10480 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
10481 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10483 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10484 list_del(&ioa_cfg->queue);
10485 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10487 if (ioa_cfg->sdt_state == ABORT_DUMP)
10488 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
10489 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10491 ipr_free_all_resources(ioa_cfg);
10497 * ipr_remove - IOA hot plug remove entry point
10498 * @pdev: pci device struct
10500 * Adapter hot plug remove entry point.
10505 static void ipr_remove(struct pci_dev *pdev)
10507 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10511 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10513 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10515 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10516 &ipr_ioa_async_err_log);
10517 scsi_remove_host(ioa_cfg->host);
10519 __ipr_remove(pdev);
10525 * ipr_probe - Adapter hot plug add entry point
10528 * 0 on success / non-zero on failure
10530 static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
10532 struct ipr_ioa_cfg *ioa_cfg;
10533 unsigned long flags;
10536 rc = ipr_probe_ioa(pdev, dev_id);
10541 ioa_cfg = pci_get_drvdata(pdev);
10542 rc = ipr_probe_ioa_part2(ioa_cfg);
10545 __ipr_remove(pdev);
10549 rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
10552 __ipr_remove(pdev);
10556 rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
10560 scsi_remove_host(ioa_cfg->host);
10561 __ipr_remove(pdev);
10565 rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj,
10566 &ipr_ioa_async_err_log);
10569 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10571 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10573 scsi_remove_host(ioa_cfg->host);
10574 __ipr_remove(pdev);
10578 rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
10582 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10583 &ipr_ioa_async_err_log);
10584 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10586 scsi_remove_host(ioa_cfg->host);
10587 __ipr_remove(pdev);
10590 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10591 ioa_cfg->scan_enabled = 1;
10592 schedule_work(&ioa_cfg->work_q);
10593 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10595 ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight;
10597 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10598 for (i = 1; i < ioa_cfg->hrrq_num; i++) {
10599 irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
10600 ioa_cfg->iopoll_weight, ipr_iopoll);
10604 scsi_scan_host(ioa_cfg->host);
10610 * ipr_shutdown - Shutdown handler.
10611 * @pdev: pci device struct
10613 * This function is invoked upon system shutdown/reboot. It will issue
10614 * an adapter shutdown to the adapter to flush the write cache.
10619 static void ipr_shutdown(struct pci_dev *pdev)
10621 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10622 unsigned long lock_flags = 0;
10623 enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL;
10626 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10627 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10628 ioa_cfg->iopoll_weight = 0;
10629 for (i = 1; i < ioa_cfg->hrrq_num; i++)
10630 irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
10633 while (ioa_cfg->in_reset_reload) {
10634 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10635 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10636 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10639 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64)
10640 shutdown_type = IPR_SHUTDOWN_QUIESCE;
10642 ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type);
10643 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10644 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10645 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) {
10646 ipr_free_irqs(ioa_cfg);
10647 pci_disable_device(ioa_cfg->pdev);
10651 static struct pci_device_id ipr_pci_table[] = {
10652 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10653 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
10654 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10655 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
10656 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10657 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
10658 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10659 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
10660 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10661 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
10662 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10663 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
10664 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10665 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
10666 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10667 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
10668 IPR_USE_LONG_TRANSOP_TIMEOUT },
10669 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10670 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10671 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10672 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10673 IPR_USE_LONG_TRANSOP_TIMEOUT },
10674 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10675 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10676 IPR_USE_LONG_TRANSOP_TIMEOUT },
10677 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10678 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10679 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10680 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10681 IPR_USE_LONG_TRANSOP_TIMEOUT},
10682 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10683 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10684 IPR_USE_LONG_TRANSOP_TIMEOUT },
10685 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10686 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
10687 IPR_USE_LONG_TRANSOP_TIMEOUT },
10688 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10689 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
10690 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10691 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 },
10692 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10693 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
10694 IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
10695 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
10696 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
10697 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10698 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
10699 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10700 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
10701 IPR_USE_LONG_TRANSOP_TIMEOUT },
10702 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10703 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
10704 IPR_USE_LONG_TRANSOP_TIMEOUT },
10705 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10706 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
10707 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10708 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
10709 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10710 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
10711 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10712 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 },
10713 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10714 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 },
10715 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10716 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 },
10717 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10718 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
10719 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10720 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
10721 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10722 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
10723 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10724 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 },
10725 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10726 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
10727 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10728 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 },
10729 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10730 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 },
10731 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10732 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 },
10733 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10734 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 },
10735 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10736 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 },
10737 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10738 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 },
10739 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10740 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 },
10741 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10742 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 },
10743 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10744 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 },
10745 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10746 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 },
10747 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10748 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 },
10749 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10750 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 },
10751 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10752 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 },
10753 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10754 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 },
10755 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10756 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 },
10757 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10758 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 },
10759 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10760 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 },
10763 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
10765 static const struct pci_error_handlers ipr_err_handler = {
10766 .error_detected = ipr_pci_error_detected,
10767 .mmio_enabled = ipr_pci_mmio_enabled,
10768 .slot_reset = ipr_pci_slot_reset,
10771 static struct pci_driver ipr_driver = {
10773 .id_table = ipr_pci_table,
10774 .probe = ipr_probe,
10775 .remove = ipr_remove,
10776 .shutdown = ipr_shutdown,
10777 .err_handler = &ipr_err_handler,
10781 * ipr_halt_done - Shutdown prepare completion
10786 static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
10788 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
10792 * ipr_halt - Issue shutdown prepare to all adapters
10795 * NOTIFY_OK on success / NOTIFY_DONE on failure
10797 static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
10799 struct ipr_cmnd *ipr_cmd;
10800 struct ipr_ioa_cfg *ioa_cfg;
10801 unsigned long flags = 0, driver_lock_flags;
10803 if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
10804 return NOTIFY_DONE;
10806 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10808 list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
10809 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10810 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
10811 (ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) {
10812 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10816 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
10817 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
10818 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
10819 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
10820 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
10822 ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
10823 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10825 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10830 static struct notifier_block ipr_notifier = {
10835 * ipr_init - Module entry point
10838 * 0 on success / negative value on failure
10840 static int __init ipr_init(void)
10842 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10843 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
10845 register_reboot_notifier(&ipr_notifier);
10846 return pci_register_driver(&ipr_driver);
10850 * ipr_exit - Module unload
10852 * Module unload entry point.
10857 static void __exit ipr_exit(void)
10859 unregister_reboot_notifier(&ipr_notifier);
10860 pci_unregister_driver(&ipr_driver);
10863 module_init(ipr_init);
10864 module_exit(ipr_exit);