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
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[0] },
190 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[0] },
191 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[0] },
192 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[0] },
193 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
, IPR_USE_MSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[0] },
194 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_SNIPE
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[1] },
195 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
, IPR_USE_LSI
, IPR_SIS32
, IPR_PCI_CFG
, &ipr_chip_cfg
[1] },
196 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
, IPR_USE_MSI
, IPR_SIS64
, IPR_MMIO
, &ipr_chip_cfg
[2] },
197 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
, IPR_USE_MSI
, IPR_SIS64
, IPR_MMIO
, &ipr_chip_cfg
[2] },
198 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_RATTLESNAKE
, IPR_USE_MSI
, 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 {0x06288000, 0, IPR_DEFAULT_LOG_LEVEL
,
439 "3140: Device bus not ready to ready transition"},
440 {0x06290000, 0, IPR_DEFAULT_LOG_LEVEL
,
441 "FFFB: SCSI bus was reset"},
443 "FFFE: SCSI bus transition to single ended"},
445 "FFFE: SCSI bus transition to LVD"},
446 {0x06298000, 0, IPR_DEFAULT_LOG_LEVEL
,
447 "FFFB: SCSI bus was reset by another initiator"},
448 {0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL
,
449 "3029: A device replacement has occurred"},
450 {0x063F8300, 0, IPR_DEFAULT_LOG_LEVEL
,
451 "4102: Device bus fabric performance degradation"},
452 {0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL
,
453 "9051: IOA cache data exists for a missing or failed device"},
454 {0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL
,
455 "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
456 {0x06670100, 0, IPR_DEFAULT_LOG_LEVEL
,
457 "9025: Disk unit is not supported at its physical location"},
458 {0x06670600, 0, IPR_DEFAULT_LOG_LEVEL
,
459 "3020: IOA detected a SCSI bus configuration error"},
460 {0x06678000, 0, IPR_DEFAULT_LOG_LEVEL
,
461 "3150: SCSI bus configuration error"},
462 {0x06678100, 0, IPR_DEFAULT_LOG_LEVEL
,
463 "9074: Asymmetric advanced function disk configuration"},
464 {0x06678300, 0, IPR_DEFAULT_LOG_LEVEL
,
465 "4040: Incomplete multipath connection between IOA and enclosure"},
466 {0x06678400, 0, IPR_DEFAULT_LOG_LEVEL
,
467 "4041: Incomplete multipath connection between enclosure and device"},
468 {0x06678500, 0, IPR_DEFAULT_LOG_LEVEL
,
469 "9075: Incomplete multipath connection between IOA and remote IOA"},
470 {0x06678600, 0, IPR_DEFAULT_LOG_LEVEL
,
471 "9076: Configuration error, missing remote IOA"},
472 {0x06679100, 0, IPR_DEFAULT_LOG_LEVEL
,
473 "4050: Enclosure does not support a required multipath function"},
474 {0x06679800, 0, IPR_DEFAULT_LOG_LEVEL
,
475 "4121: Configuration error, required cable is missing"},
476 {0x06679900, 0, IPR_DEFAULT_LOG_LEVEL
,
477 "4122: Cable is not plugged into the correct location on remote IOA"},
478 {0x06679A00, 0, IPR_DEFAULT_LOG_LEVEL
,
479 "4123: Configuration error, invalid cable vital product data"},
480 {0x06679B00, 0, IPR_DEFAULT_LOG_LEVEL
,
481 "4124: Configuration error, both cable ends are plugged into the same IOA"},
482 {0x06690000, 0, IPR_DEFAULT_LOG_LEVEL
,
483 "4070: Logically bad block written on device"},
484 {0x06690200, 0, IPR_DEFAULT_LOG_LEVEL
,
485 "9041: Array protection temporarily suspended"},
486 {0x06698200, 0, IPR_DEFAULT_LOG_LEVEL
,
487 "9042: Corrupt array parity detected on specified device"},
488 {0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL
,
489 "9030: Array no longer protected due to missing or failed disk unit"},
490 {0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL
,
491 "9071: Link operational transition"},
492 {0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL
,
493 "9072: Link not operational transition"},
494 {0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL
,
495 "9032: Array exposed but still protected"},
496 {0x066B8300, 0, IPR_DEFAULT_LOG_LEVEL
+ 1,
497 "70DD: Device forced failed by disrupt device command"},
498 {0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL
,
499 "4061: Multipath redundancy level got better"},
500 {0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL
,
501 "4060: Multipath redundancy level got worse"},
502 {0x06808100, 0, IPR_DEFAULT_LOG_LEVEL
,
503 "9083: Device raw mode enabled"},
504 {0x06808200, 0, IPR_DEFAULT_LOG_LEVEL
,
505 "9084: Device raw mode disabled"},
507 "Failure due to other device"},
508 {0x07278000, 0, IPR_DEFAULT_LOG_LEVEL
,
509 "9008: IOA does not support functions expected by devices"},
510 {0x07278100, 0, IPR_DEFAULT_LOG_LEVEL
,
511 "9010: Cache data associated with attached devices cannot be found"},
512 {0x07278200, 0, IPR_DEFAULT_LOG_LEVEL
,
513 "9011: Cache data belongs to devices other than those attached"},
514 {0x07278400, 0, IPR_DEFAULT_LOG_LEVEL
,
515 "9020: Array missing 2 or more devices with only 1 device present"},
516 {0x07278500, 0, IPR_DEFAULT_LOG_LEVEL
,
517 "9021: Array missing 2 or more devices with 2 or more devices present"},
518 {0x07278600, 0, IPR_DEFAULT_LOG_LEVEL
,
519 "9022: Exposed array is missing a required device"},
520 {0x07278700, 0, IPR_DEFAULT_LOG_LEVEL
,
521 "9023: Array member(s) not at required physical locations"},
522 {0x07278800, 0, IPR_DEFAULT_LOG_LEVEL
,
523 "9024: Array not functional due to present hardware configuration"},
524 {0x07278900, 0, IPR_DEFAULT_LOG_LEVEL
,
525 "9026: Array not functional due to present hardware configuration"},
526 {0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL
,
527 "9027: Array is missing a device and parity is out of sync"},
528 {0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL
,
529 "9028: Maximum number of arrays already exist"},
530 {0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL
,
531 "9050: Required cache data cannot be located for a disk unit"},
532 {0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL
,
533 "9052: Cache data exists for a device that has been modified"},
534 {0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL
,
535 "9054: IOA resources not available due to previous problems"},
536 {0x07279100, 0, IPR_DEFAULT_LOG_LEVEL
,
537 "9092: Disk unit requires initialization before use"},
538 {0x07279200, 0, IPR_DEFAULT_LOG_LEVEL
,
539 "9029: Incorrect hardware configuration change has been detected"},
540 {0x07279600, 0, IPR_DEFAULT_LOG_LEVEL
,
541 "9060: One or more disk pairs are missing from an array"},
542 {0x07279700, 0, IPR_DEFAULT_LOG_LEVEL
,
543 "9061: One or more disks are missing from an array"},
544 {0x07279800, 0, IPR_DEFAULT_LOG_LEVEL
,
545 "9062: One or more disks are missing from an array"},
546 {0x07279900, 0, IPR_DEFAULT_LOG_LEVEL
,
547 "9063: Maximum number of functional arrays has been exceeded"},
549 "Data protect, other volume set problem"},
551 "Aborted command, invalid descriptor"},
553 "Target operating conditions have changed, dual adapter takeover"},
555 "Aborted command, medium removal prevented"},
557 "Command terminated by host"},
559 "Aborted command, command terminated by host"}
562 static const struct ipr_ses_table_entry ipr_ses_table
[] = {
563 { "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
564 { "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
565 { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
566 { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
567 { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
568 { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
569 { "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
570 { "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
571 { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
572 { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
573 { "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
574 { "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
575 { "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
579 * Function Prototypes
581 static int ipr_reset_alert(struct ipr_cmnd
*);
582 static void ipr_process_ccn(struct ipr_cmnd
*);
583 static void ipr_process_error(struct ipr_cmnd
*);
584 static void ipr_reset_ioa_job(struct ipr_cmnd
*);
585 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg
*,
586 enum ipr_shutdown_type
);
588 #ifdef CONFIG_SCSI_IPR_TRACE
590 * ipr_trc_hook - Add a trace entry to the driver trace
591 * @ipr_cmd: ipr command struct
593 * @add_data: additional data
598 static void ipr_trc_hook(struct ipr_cmnd
*ipr_cmd
,
599 u8 type
, u32 add_data
)
601 struct ipr_trace_entry
*trace_entry
;
602 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
603 unsigned int trace_index
;
605 trace_index
= atomic_add_return(1, &ioa_cfg
->trace_index
) & IPR_TRACE_INDEX_MASK
;
606 trace_entry
= &ioa_cfg
->trace
[trace_index
];
607 trace_entry
->time
= jiffies
;
608 trace_entry
->op_code
= ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0];
609 trace_entry
->type
= type
;
610 if (ipr_cmd
->ioa_cfg
->sis64
)
611 trace_entry
->ata_op_code
= ipr_cmd
->i
.ata_ioadl
.regs
.command
;
613 trace_entry
->ata_op_code
= ipr_cmd
->ioarcb
.u
.add_data
.u
.regs
.command
;
614 trace_entry
->cmd_index
= ipr_cmd
->cmd_index
& 0xff;
615 trace_entry
->res_handle
= ipr_cmd
->ioarcb
.res_handle
;
616 trace_entry
->u
.add_data
= add_data
;
620 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
624 * ipr_lock_and_done - Acquire lock and complete command
625 * @ipr_cmd: ipr command struct
630 static void ipr_lock_and_done(struct ipr_cmnd
*ipr_cmd
)
632 unsigned long lock_flags
;
633 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
635 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
636 ipr_cmd
->done(ipr_cmd
);
637 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
641 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
642 * @ipr_cmd: ipr command struct
647 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd
*ipr_cmd
)
649 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
650 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
651 struct ipr_ioasa64
*ioasa64
= &ipr_cmd
->s
.ioasa64
;
652 dma_addr_t dma_addr
= ipr_cmd
->dma_addr
;
655 hrrq_id
= ioarcb
->cmd_pkt
.hrrq_id
;
656 memset(&ioarcb
->cmd_pkt
, 0, sizeof(struct ipr_cmd_pkt
));
657 ioarcb
->cmd_pkt
.hrrq_id
= hrrq_id
;
658 ioarcb
->data_transfer_length
= 0;
659 ioarcb
->read_data_transfer_length
= 0;
660 ioarcb
->ioadl_len
= 0;
661 ioarcb
->read_ioadl_len
= 0;
663 if (ipr_cmd
->ioa_cfg
->sis64
) {
664 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
665 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl64
));
666 ioasa64
->u
.gata
.status
= 0;
668 ioarcb
->write_ioadl_addr
=
669 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl
));
670 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
671 ioasa
->u
.gata
.status
= 0;
674 ioasa
->hdr
.ioasc
= 0;
675 ioasa
->hdr
.residual_data_len
= 0;
676 ipr_cmd
->scsi_cmd
= NULL
;
678 ipr_cmd
->sense_buffer
[0] = 0;
679 ipr_cmd
->dma_use_sg
= 0;
683 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
684 * @ipr_cmd: ipr command struct
689 static void ipr_init_ipr_cmnd(struct ipr_cmnd
*ipr_cmd
,
690 void (*fast_done
) (struct ipr_cmnd
*))
692 ipr_reinit_ipr_cmnd(ipr_cmd
);
693 ipr_cmd
->u
.scratch
= 0;
694 ipr_cmd
->sibling
= NULL
;
695 ipr_cmd
->eh_comp
= NULL
;
696 ipr_cmd
->fast_done
= fast_done
;
697 init_timer(&ipr_cmd
->timer
);
701 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
702 * @ioa_cfg: ioa config struct
705 * pointer to ipr command struct
708 struct ipr_cmnd
*__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue
*hrrq
)
710 struct ipr_cmnd
*ipr_cmd
= NULL
;
712 if (likely(!list_empty(&hrrq
->hrrq_free_q
))) {
713 ipr_cmd
= list_entry(hrrq
->hrrq_free_q
.next
,
714 struct ipr_cmnd
, queue
);
715 list_del(&ipr_cmd
->queue
);
723 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
724 * @ioa_cfg: ioa config struct
727 * pointer to ipr command struct
730 struct ipr_cmnd
*ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg
*ioa_cfg
)
732 struct ipr_cmnd
*ipr_cmd
=
733 __ipr_get_free_ipr_cmnd(&ioa_cfg
->hrrq
[IPR_INIT_HRRQ
]);
734 ipr_init_ipr_cmnd(ipr_cmd
, ipr_lock_and_done
);
739 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
740 * @ioa_cfg: ioa config struct
741 * @clr_ints: interrupts to clear
743 * This function masks all interrupts on the adapter, then clears the
744 * interrupts specified in the mask
749 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg
*ioa_cfg
,
752 volatile u32 int_reg
;
755 /* Stop new interrupts */
756 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
757 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
758 ioa_cfg
->hrrq
[i
].allow_interrupts
= 0;
759 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
763 /* Set interrupt mask to stop all new interrupts */
765 writeq(~0, ioa_cfg
->regs
.set_interrupt_mask_reg
);
767 writel(~0, ioa_cfg
->regs
.set_interrupt_mask_reg
);
769 /* Clear any pending interrupts */
771 writel(~0, ioa_cfg
->regs
.clr_interrupt_reg
);
772 writel(clr_ints
, ioa_cfg
->regs
.clr_interrupt_reg32
);
773 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
777 * ipr_save_pcix_cmd_reg - Save PCI-X command register
778 * @ioa_cfg: ioa config struct
781 * 0 on success / -EIO on failure
783 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg
*ioa_cfg
)
785 int pcix_cmd_reg
= pci_find_capability(ioa_cfg
->pdev
, PCI_CAP_ID_PCIX
);
787 if (pcix_cmd_reg
== 0)
790 if (pci_read_config_word(ioa_cfg
->pdev
, pcix_cmd_reg
+ PCI_X_CMD
,
791 &ioa_cfg
->saved_pcix_cmd_reg
) != PCIBIOS_SUCCESSFUL
) {
792 dev_err(&ioa_cfg
->pdev
->dev
, "Failed to save PCI-X command register\n");
796 ioa_cfg
->saved_pcix_cmd_reg
|= PCI_X_CMD_DPERR_E
| PCI_X_CMD_ERO
;
801 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
802 * @ioa_cfg: ioa config struct
805 * 0 on success / -EIO on failure
807 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg
*ioa_cfg
)
809 int pcix_cmd_reg
= pci_find_capability(ioa_cfg
->pdev
, PCI_CAP_ID_PCIX
);
812 if (pci_write_config_word(ioa_cfg
->pdev
, pcix_cmd_reg
+ PCI_X_CMD
,
813 ioa_cfg
->saved_pcix_cmd_reg
) != PCIBIOS_SUCCESSFUL
) {
814 dev_err(&ioa_cfg
->pdev
->dev
, "Failed to setup PCI-X command register\n");
823 * ipr_sata_eh_done - done function for aborted SATA commands
824 * @ipr_cmd: ipr command struct
826 * This function is invoked for ops generated to SATA
827 * devices which are being aborted.
832 static void ipr_sata_eh_done(struct ipr_cmnd
*ipr_cmd
)
834 struct ata_queued_cmd
*qc
= ipr_cmd
->qc
;
835 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
837 qc
->err_mask
|= AC_ERR_OTHER
;
838 sata_port
->ioasa
.status
|= ATA_BUSY
;
839 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
844 * ipr_scsi_eh_done - mid-layer done function for aborted ops
845 * @ipr_cmd: ipr command struct
847 * This function is invoked by the interrupt handler for
848 * ops generated by the SCSI mid-layer which are being aborted.
853 static void ipr_scsi_eh_done(struct ipr_cmnd
*ipr_cmd
)
855 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
857 scsi_cmd
->result
|= (DID_ERROR
<< 16);
859 scsi_dma_unmap(ipr_cmd
->scsi_cmd
);
860 scsi_cmd
->scsi_done(scsi_cmd
);
861 if (ipr_cmd
->eh_comp
)
862 complete(ipr_cmd
->eh_comp
);
863 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
867 * ipr_fail_all_ops - Fails all outstanding ops.
868 * @ioa_cfg: ioa config struct
870 * This function fails all outstanding ops.
875 static void ipr_fail_all_ops(struct ipr_ioa_cfg
*ioa_cfg
)
877 struct ipr_cmnd
*ipr_cmd
, *temp
;
878 struct ipr_hrr_queue
*hrrq
;
881 for_each_hrrq(hrrq
, ioa_cfg
) {
882 spin_lock(&hrrq
->_lock
);
883 list_for_each_entry_safe(ipr_cmd
,
884 temp
, &hrrq
->hrrq_pending_q
, queue
) {
885 list_del(&ipr_cmd
->queue
);
887 ipr_cmd
->s
.ioasa
.hdr
.ioasc
=
888 cpu_to_be32(IPR_IOASC_IOA_WAS_RESET
);
889 ipr_cmd
->s
.ioasa
.hdr
.ilid
=
890 cpu_to_be32(IPR_DRIVER_ILID
);
892 if (ipr_cmd
->scsi_cmd
)
893 ipr_cmd
->done
= ipr_scsi_eh_done
;
894 else if (ipr_cmd
->qc
)
895 ipr_cmd
->done
= ipr_sata_eh_done
;
897 ipr_trc_hook(ipr_cmd
, IPR_TRACE_FINISH
,
898 IPR_IOASC_IOA_WAS_RESET
);
899 del_timer(&ipr_cmd
->timer
);
900 ipr_cmd
->done(ipr_cmd
);
902 spin_unlock(&hrrq
->_lock
);
908 * ipr_send_command - Send driver initiated requests.
909 * @ipr_cmd: ipr command struct
911 * This function sends a command to the adapter using the correct write call.
912 * In the case of sis64, calculate the ioarcb size required. Then or in the
918 static void ipr_send_command(struct ipr_cmnd
*ipr_cmd
)
920 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
921 dma_addr_t send_dma_addr
= ipr_cmd
->dma_addr
;
923 if (ioa_cfg
->sis64
) {
924 /* The default size is 256 bytes */
925 send_dma_addr
|= 0x1;
927 /* If the number of ioadls * size of ioadl > 128 bytes,
928 then use a 512 byte ioarcb */
929 if (ipr_cmd
->dma_use_sg
* sizeof(struct ipr_ioadl64_desc
) > 128 )
930 send_dma_addr
|= 0x4;
931 writeq(send_dma_addr
, ioa_cfg
->regs
.ioarrin_reg
);
933 writel(send_dma_addr
, ioa_cfg
->regs
.ioarrin_reg
);
937 * ipr_do_req - Send driver initiated requests.
938 * @ipr_cmd: ipr command struct
939 * @done: done function
940 * @timeout_func: timeout function
941 * @timeout: timeout value
943 * This function sends the specified command to the adapter with the
944 * timeout given. The done function is invoked on command completion.
949 static void ipr_do_req(struct ipr_cmnd
*ipr_cmd
,
950 void (*done
) (struct ipr_cmnd
*),
951 void (*timeout_func
) (struct ipr_cmnd
*), u32 timeout
)
953 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
955 ipr_cmd
->done
= done
;
957 ipr_cmd
->timer
.data
= (unsigned long) ipr_cmd
;
958 ipr_cmd
->timer
.expires
= jiffies
+ timeout
;
959 ipr_cmd
->timer
.function
= (void (*)(unsigned long))timeout_func
;
961 add_timer(&ipr_cmd
->timer
);
963 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, 0);
965 ipr_send_command(ipr_cmd
);
969 * ipr_internal_cmd_done - Op done function for an internally generated op.
970 * @ipr_cmd: ipr command struct
972 * This function is the op done function for an internally generated,
973 * blocking op. It simply wakes the sleeping thread.
978 static void ipr_internal_cmd_done(struct ipr_cmnd
*ipr_cmd
)
980 if (ipr_cmd
->sibling
)
981 ipr_cmd
->sibling
= NULL
;
983 complete(&ipr_cmd
->completion
);
987 * ipr_init_ioadl - initialize the ioadl for the correct SIS type
988 * @ipr_cmd: ipr command struct
989 * @dma_addr: dma address
990 * @len: transfer length
991 * @flags: ioadl flag value
993 * This function initializes an ioadl in the case where there is only a single
999 static void ipr_init_ioadl(struct ipr_cmnd
*ipr_cmd
, dma_addr_t dma_addr
,
1002 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
1003 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ioadl64
;
1005 ipr_cmd
->dma_use_sg
= 1;
1007 if (ipr_cmd
->ioa_cfg
->sis64
) {
1008 ioadl64
->flags
= cpu_to_be32(flags
);
1009 ioadl64
->data_len
= cpu_to_be32(len
);
1010 ioadl64
->address
= cpu_to_be64(dma_addr
);
1012 ipr_cmd
->ioarcb
.ioadl_len
=
1013 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
));
1014 ipr_cmd
->ioarcb
.data_transfer_length
= cpu_to_be32(len
);
1016 ioadl
->flags_and_data_len
= cpu_to_be32(flags
| len
);
1017 ioadl
->address
= cpu_to_be32(dma_addr
);
1019 if (flags
== IPR_IOADL_FLAGS_READ_LAST
) {
1020 ipr_cmd
->ioarcb
.read_ioadl_len
=
1021 cpu_to_be32(sizeof(struct ipr_ioadl_desc
));
1022 ipr_cmd
->ioarcb
.read_data_transfer_length
= cpu_to_be32(len
);
1024 ipr_cmd
->ioarcb
.ioadl_len
=
1025 cpu_to_be32(sizeof(struct ipr_ioadl_desc
));
1026 ipr_cmd
->ioarcb
.data_transfer_length
= cpu_to_be32(len
);
1032 * ipr_send_blocking_cmd - Send command and sleep on its completion.
1033 * @ipr_cmd: ipr command struct
1034 * @timeout_func: function to invoke if command times out
1040 static void ipr_send_blocking_cmd(struct ipr_cmnd
*ipr_cmd
,
1041 void (*timeout_func
) (struct ipr_cmnd
*ipr_cmd
),
1044 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
1046 init_completion(&ipr_cmd
->completion
);
1047 ipr_do_req(ipr_cmd
, ipr_internal_cmd_done
, timeout_func
, timeout
);
1049 spin_unlock_irq(ioa_cfg
->host
->host_lock
);
1050 wait_for_completion(&ipr_cmd
->completion
);
1051 spin_lock_irq(ioa_cfg
->host
->host_lock
);
1054 static int ipr_get_hrrq_index(struct ipr_ioa_cfg
*ioa_cfg
)
1058 if (ioa_cfg
->hrrq_num
== 1)
1061 hrrq
= atomic_add_return(1, &ioa_cfg
->hrrq_index
);
1062 hrrq
= (hrrq
% (ioa_cfg
->hrrq_num
- 1)) + 1;
1068 * ipr_send_hcam - Send an HCAM to the adapter.
1069 * @ioa_cfg: ioa config struct
1071 * @hostrcb: hostrcb struct
1073 * This function will send a Host Controlled Async command to the adapter.
1074 * If HCAMs are currently not allowed to be issued to the adapter, it will
1075 * place the hostrcb on the free queue.
1080 static void ipr_send_hcam(struct ipr_ioa_cfg
*ioa_cfg
, u8 type
,
1081 struct ipr_hostrcb
*hostrcb
)
1083 struct ipr_cmnd
*ipr_cmd
;
1084 struct ipr_ioarcb
*ioarcb
;
1086 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
) {
1087 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
1088 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
1089 list_add_tail(&hostrcb
->queue
, &ioa_cfg
->hostrcb_pending_q
);
1091 ipr_cmd
->u
.hostrcb
= hostrcb
;
1092 ioarcb
= &ipr_cmd
->ioarcb
;
1094 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
1095 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_HCAM
;
1096 ioarcb
->cmd_pkt
.cdb
[0] = IPR_HOST_CONTROLLED_ASYNC
;
1097 ioarcb
->cmd_pkt
.cdb
[1] = type
;
1098 ioarcb
->cmd_pkt
.cdb
[7] = (sizeof(hostrcb
->hcam
) >> 8) & 0xff;
1099 ioarcb
->cmd_pkt
.cdb
[8] = sizeof(hostrcb
->hcam
) & 0xff;
1101 ipr_init_ioadl(ipr_cmd
, hostrcb
->hostrcb_dma
,
1102 sizeof(hostrcb
->hcam
), IPR_IOADL_FLAGS_READ_LAST
);
1104 if (type
== IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
)
1105 ipr_cmd
->done
= ipr_process_ccn
;
1107 ipr_cmd
->done
= ipr_process_error
;
1109 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, IPR_IOA_RES_ADDR
);
1111 ipr_send_command(ipr_cmd
);
1113 list_add_tail(&hostrcb
->queue
, &ioa_cfg
->hostrcb_free_q
);
1118 * ipr_update_ata_class - Update the ata class in the resource entry
1119 * @res: resource entry struct
1120 * @proto: cfgte device bus protocol value
1125 static void ipr_update_ata_class(struct ipr_resource_entry
*res
, unsigned int proto
)
1128 case IPR_PROTO_SATA
:
1129 case IPR_PROTO_SAS_STP
:
1130 res
->ata_class
= ATA_DEV_ATA
;
1132 case IPR_PROTO_SATA_ATAPI
:
1133 case IPR_PROTO_SAS_STP_ATAPI
:
1134 res
->ata_class
= ATA_DEV_ATAPI
;
1137 res
->ata_class
= ATA_DEV_UNKNOWN
;
1143 * ipr_init_res_entry - Initialize a resource entry struct.
1144 * @res: resource entry struct
1145 * @cfgtew: config table entry wrapper struct
1150 static void ipr_init_res_entry(struct ipr_resource_entry
*res
,
1151 struct ipr_config_table_entry_wrapper
*cfgtew
)
1155 struct ipr_ioa_cfg
*ioa_cfg
= res
->ioa_cfg
;
1156 struct ipr_resource_entry
*gscsi_res
= NULL
;
1158 res
->needs_sync_complete
= 0;
1161 res
->del_from_ml
= 0;
1162 res
->resetting_device
= 0;
1163 res
->reset_occurred
= 0;
1165 res
->sata_port
= NULL
;
1167 if (ioa_cfg
->sis64
) {
1168 proto
= cfgtew
->u
.cfgte64
->proto
;
1169 res
->flags
= be16_to_cpu(cfgtew
->u
.cfgte64
->flags
);
1170 res
->res_flags
= be16_to_cpu(cfgtew
->u
.cfgte64
->res_flags
);
1171 res
->qmodel
= IPR_QUEUEING_MODEL64(res
);
1172 res
->type
= cfgtew
->u
.cfgte64
->res_type
;
1174 memcpy(res
->res_path
, &cfgtew
->u
.cfgte64
->res_path
,
1175 sizeof(res
->res_path
));
1178 memcpy(&res
->dev_lun
.scsi_lun
, &cfgtew
->u
.cfgte64
->lun
,
1179 sizeof(res
->dev_lun
.scsi_lun
));
1180 res
->lun
= scsilun_to_int(&res
->dev_lun
);
1182 if (res
->type
== IPR_RES_TYPE_GENERIC_SCSI
) {
1183 list_for_each_entry(gscsi_res
, &ioa_cfg
->used_res_q
, queue
) {
1184 if (gscsi_res
->dev_id
== cfgtew
->u
.cfgte64
->dev_id
) {
1186 res
->target
= gscsi_res
->target
;
1191 res
->target
= find_first_zero_bit(ioa_cfg
->target_ids
,
1192 ioa_cfg
->max_devs_supported
);
1193 set_bit(res
->target
, ioa_cfg
->target_ids
);
1195 } else if (res
->type
== IPR_RES_TYPE_IOAFP
) {
1196 res
->bus
= IPR_IOAFP_VIRTUAL_BUS
;
1198 } else if (res
->type
== IPR_RES_TYPE_ARRAY
) {
1199 res
->bus
= IPR_ARRAY_VIRTUAL_BUS
;
1200 res
->target
= find_first_zero_bit(ioa_cfg
->array_ids
,
1201 ioa_cfg
->max_devs_supported
);
1202 set_bit(res
->target
, ioa_cfg
->array_ids
);
1203 } else if (res
->type
== IPR_RES_TYPE_VOLUME_SET
) {
1204 res
->bus
= IPR_VSET_VIRTUAL_BUS
;
1205 res
->target
= find_first_zero_bit(ioa_cfg
->vset_ids
,
1206 ioa_cfg
->max_devs_supported
);
1207 set_bit(res
->target
, ioa_cfg
->vset_ids
);
1209 res
->target
= find_first_zero_bit(ioa_cfg
->target_ids
,
1210 ioa_cfg
->max_devs_supported
);
1211 set_bit(res
->target
, ioa_cfg
->target_ids
);
1214 proto
= cfgtew
->u
.cfgte
->proto
;
1215 res
->qmodel
= IPR_QUEUEING_MODEL(res
);
1216 res
->flags
= cfgtew
->u
.cfgte
->flags
;
1217 if (res
->flags
& IPR_IS_IOA_RESOURCE
)
1218 res
->type
= IPR_RES_TYPE_IOAFP
;
1220 res
->type
= cfgtew
->u
.cfgte
->rsvd_subtype
& 0x0f;
1222 res
->bus
= cfgtew
->u
.cfgte
->res_addr
.bus
;
1223 res
->target
= cfgtew
->u
.cfgte
->res_addr
.target
;
1224 res
->lun
= cfgtew
->u
.cfgte
->res_addr
.lun
;
1225 res
->lun_wwn
= get_unaligned_be64(cfgtew
->u
.cfgte
->lun_wwn
);
1228 ipr_update_ata_class(res
, proto
);
1232 * ipr_is_same_device - Determine if two devices are the same.
1233 * @res: resource entry struct
1234 * @cfgtew: config table entry wrapper struct
1237 * 1 if the devices are the same / 0 otherwise
1239 static int ipr_is_same_device(struct ipr_resource_entry
*res
,
1240 struct ipr_config_table_entry_wrapper
*cfgtew
)
1242 if (res
->ioa_cfg
->sis64
) {
1243 if (!memcmp(&res
->dev_id
, &cfgtew
->u
.cfgte64
->dev_id
,
1244 sizeof(cfgtew
->u
.cfgte64
->dev_id
)) &&
1245 !memcmp(&res
->dev_lun
.scsi_lun
, &cfgtew
->u
.cfgte64
->lun
,
1246 sizeof(cfgtew
->u
.cfgte64
->lun
))) {
1250 if (res
->bus
== cfgtew
->u
.cfgte
->res_addr
.bus
&&
1251 res
->target
== cfgtew
->u
.cfgte
->res_addr
.target
&&
1252 res
->lun
== cfgtew
->u
.cfgte
->res_addr
.lun
)
1260 * __ipr_format_res_path - Format the resource path for printing.
1261 * @res_path: resource path
1263 * @len: length of buffer provided
1268 static char *__ipr_format_res_path(u8
*res_path
, char *buffer
, int len
)
1274 p
+= snprintf(p
, buffer
+ len
- p
, "%02X", res_path
[0]);
1275 for (i
= 1; res_path
[i
] != 0xff && ((i
* 3) < len
); i
++)
1276 p
+= snprintf(p
, buffer
+ len
- p
, "-%02X", res_path
[i
]);
1282 * ipr_format_res_path - Format the resource path for printing.
1283 * @ioa_cfg: ioa config struct
1284 * @res_path: resource path
1286 * @len: length of buffer provided
1291 static char *ipr_format_res_path(struct ipr_ioa_cfg
*ioa_cfg
,
1292 u8
*res_path
, char *buffer
, int len
)
1297 p
+= snprintf(p
, buffer
+ len
- p
, "%d/", ioa_cfg
->host
->host_no
);
1298 __ipr_format_res_path(res_path
, p
, len
- (buffer
- p
));
1303 * ipr_update_res_entry - Update the resource entry.
1304 * @res: resource entry struct
1305 * @cfgtew: config table entry wrapper struct
1310 static void ipr_update_res_entry(struct ipr_resource_entry
*res
,
1311 struct ipr_config_table_entry_wrapper
*cfgtew
)
1313 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
1317 if (res
->ioa_cfg
->sis64
) {
1318 res
->flags
= be16_to_cpu(cfgtew
->u
.cfgte64
->flags
);
1319 res
->res_flags
= be16_to_cpu(cfgtew
->u
.cfgte64
->res_flags
);
1320 res
->type
= cfgtew
->u
.cfgte64
->res_type
;
1322 memcpy(&res
->std_inq_data
, &cfgtew
->u
.cfgte64
->std_inq_data
,
1323 sizeof(struct ipr_std_inq_data
));
1325 res
->qmodel
= IPR_QUEUEING_MODEL64(res
);
1326 proto
= cfgtew
->u
.cfgte64
->proto
;
1327 res
->res_handle
= cfgtew
->u
.cfgte64
->res_handle
;
1328 res
->dev_id
= cfgtew
->u
.cfgte64
->dev_id
;
1330 memcpy(&res
->dev_lun
.scsi_lun
, &cfgtew
->u
.cfgte64
->lun
,
1331 sizeof(res
->dev_lun
.scsi_lun
));
1333 if (memcmp(res
->res_path
, &cfgtew
->u
.cfgte64
->res_path
,
1334 sizeof(res
->res_path
))) {
1335 memcpy(res
->res_path
, &cfgtew
->u
.cfgte64
->res_path
,
1336 sizeof(res
->res_path
));
1340 if (res
->sdev
&& new_path
)
1341 sdev_printk(KERN_INFO
, res
->sdev
, "Resource path: %s\n",
1342 ipr_format_res_path(res
->ioa_cfg
,
1343 res
->res_path
, buffer
, sizeof(buffer
)));
1345 res
->flags
= cfgtew
->u
.cfgte
->flags
;
1346 if (res
->flags
& IPR_IS_IOA_RESOURCE
)
1347 res
->type
= IPR_RES_TYPE_IOAFP
;
1349 res
->type
= cfgtew
->u
.cfgte
->rsvd_subtype
& 0x0f;
1351 memcpy(&res
->std_inq_data
, &cfgtew
->u
.cfgte
->std_inq_data
,
1352 sizeof(struct ipr_std_inq_data
));
1354 res
->qmodel
= IPR_QUEUEING_MODEL(res
);
1355 proto
= cfgtew
->u
.cfgte
->proto
;
1356 res
->res_handle
= cfgtew
->u
.cfgte
->res_handle
;
1359 ipr_update_ata_class(res
, proto
);
1363 * ipr_clear_res_target - Clear the bit in the bit map representing the target
1365 * @res: resource entry struct
1366 * @cfgtew: config table entry wrapper struct
1371 static void ipr_clear_res_target(struct ipr_resource_entry
*res
)
1373 struct ipr_resource_entry
*gscsi_res
= NULL
;
1374 struct ipr_ioa_cfg
*ioa_cfg
= res
->ioa_cfg
;
1376 if (!ioa_cfg
->sis64
)
1379 if (res
->bus
== IPR_ARRAY_VIRTUAL_BUS
)
1380 clear_bit(res
->target
, ioa_cfg
->array_ids
);
1381 else if (res
->bus
== IPR_VSET_VIRTUAL_BUS
)
1382 clear_bit(res
->target
, ioa_cfg
->vset_ids
);
1383 else if (res
->bus
== 0 && res
->type
== IPR_RES_TYPE_GENERIC_SCSI
) {
1384 list_for_each_entry(gscsi_res
, &ioa_cfg
->used_res_q
, queue
)
1385 if (gscsi_res
->dev_id
== res
->dev_id
&& gscsi_res
!= res
)
1387 clear_bit(res
->target
, ioa_cfg
->target_ids
);
1389 } else if (res
->bus
== 0)
1390 clear_bit(res
->target
, ioa_cfg
->target_ids
);
1394 * ipr_handle_config_change - Handle a config change from the adapter
1395 * @ioa_cfg: ioa config struct
1401 static void ipr_handle_config_change(struct ipr_ioa_cfg
*ioa_cfg
,
1402 struct ipr_hostrcb
*hostrcb
)
1404 struct ipr_resource_entry
*res
= NULL
;
1405 struct ipr_config_table_entry_wrapper cfgtew
;
1406 __be32 cc_res_handle
;
1410 if (ioa_cfg
->sis64
) {
1411 cfgtew
.u
.cfgte64
= &hostrcb
->hcam
.u
.ccn
.u
.cfgte64
;
1412 cc_res_handle
= cfgtew
.u
.cfgte64
->res_handle
;
1414 cfgtew
.u
.cfgte
= &hostrcb
->hcam
.u
.ccn
.u
.cfgte
;
1415 cc_res_handle
= cfgtew
.u
.cfgte
->res_handle
;
1418 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
1419 if (res
->res_handle
== cc_res_handle
) {
1426 if (list_empty(&ioa_cfg
->free_res_q
)) {
1427 ipr_send_hcam(ioa_cfg
,
1428 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
,
1433 res
= list_entry(ioa_cfg
->free_res_q
.next
,
1434 struct ipr_resource_entry
, queue
);
1436 list_del(&res
->queue
);
1437 ipr_init_res_entry(res
, &cfgtew
);
1438 list_add_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
1441 ipr_update_res_entry(res
, &cfgtew
);
1443 if (hostrcb
->hcam
.notify_type
== IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY
) {
1445 res
->del_from_ml
= 1;
1446 res
->res_handle
= IPR_INVALID_RES_HANDLE
;
1447 schedule_work(&ioa_cfg
->work_q
);
1449 ipr_clear_res_target(res
);
1450 list_move_tail(&res
->queue
, &ioa_cfg
->free_res_q
);
1452 } else if (!res
->sdev
|| res
->del_from_ml
) {
1454 schedule_work(&ioa_cfg
->work_q
);
1457 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
, hostrcb
);
1461 * ipr_process_ccn - Op done function for a CCN.
1462 * @ipr_cmd: ipr command struct
1464 * This function is the op done function for a configuration
1465 * change notification host controlled async from the adapter.
1470 static void ipr_process_ccn(struct ipr_cmnd
*ipr_cmd
)
1472 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
1473 struct ipr_hostrcb
*hostrcb
= ipr_cmd
->u
.hostrcb
;
1474 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
1476 list_del(&hostrcb
->queue
);
1477 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
1480 if (ioasc
!= IPR_IOASC_IOA_WAS_RESET
&&
1481 ioasc
!= IPR_IOASC_ABORTED_CMD_TERM_BY_HOST
)
1482 dev_err(&ioa_cfg
->pdev
->dev
,
1483 "Host RCB failed with IOASC: 0x%08X\n", ioasc
);
1485 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
, hostrcb
);
1487 ipr_handle_config_change(ioa_cfg
, hostrcb
);
1492 * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1493 * @i: index into buffer
1494 * @buf: string to modify
1496 * This function will strip all trailing whitespace, pad the end
1497 * of the string with a single space, and NULL terminate the string.
1500 * new length of string
1502 static int strip_and_pad_whitespace(int i
, char *buf
)
1504 while (i
&& buf
[i
] == ' ')
1512 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1513 * @prefix: string to print at start of printk
1514 * @hostrcb: hostrcb pointer
1515 * @vpd: vendor/product id/sn struct
1520 static void ipr_log_vpd_compact(char *prefix
, struct ipr_hostrcb
*hostrcb
,
1521 struct ipr_vpd
*vpd
)
1523 char buffer
[IPR_VENDOR_ID_LEN
+ IPR_PROD_ID_LEN
+ IPR_SERIAL_NUM_LEN
+ 3];
1526 memcpy(buffer
, vpd
->vpids
.vendor_id
, IPR_VENDOR_ID_LEN
);
1527 i
= strip_and_pad_whitespace(IPR_VENDOR_ID_LEN
- 1, buffer
);
1529 memcpy(&buffer
[i
], vpd
->vpids
.product_id
, IPR_PROD_ID_LEN
);
1530 i
= strip_and_pad_whitespace(i
+ IPR_PROD_ID_LEN
- 1, buffer
);
1532 memcpy(&buffer
[i
], vpd
->sn
, IPR_SERIAL_NUM_LEN
);
1533 buffer
[IPR_SERIAL_NUM_LEN
+ i
] = '\0';
1535 ipr_hcam_err(hostrcb
, "%s VPID/SN: %s\n", prefix
, buffer
);
1539 * ipr_log_vpd - Log the passed VPD to the error log.
1540 * @vpd: vendor/product id/sn struct
1545 static void ipr_log_vpd(struct ipr_vpd
*vpd
)
1547 char buffer
[IPR_VENDOR_ID_LEN
+ IPR_PROD_ID_LEN
1548 + IPR_SERIAL_NUM_LEN
];
1550 memcpy(buffer
, vpd
->vpids
.vendor_id
, IPR_VENDOR_ID_LEN
);
1551 memcpy(buffer
+ IPR_VENDOR_ID_LEN
, vpd
->vpids
.product_id
,
1553 buffer
[IPR_VENDOR_ID_LEN
+ IPR_PROD_ID_LEN
] = '\0';
1554 ipr_err("Vendor/Product ID: %s\n", buffer
);
1556 memcpy(buffer
, vpd
->sn
, IPR_SERIAL_NUM_LEN
);
1557 buffer
[IPR_SERIAL_NUM_LEN
] = '\0';
1558 ipr_err(" Serial Number: %s\n", buffer
);
1562 * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1563 * @prefix: string to print at start of printk
1564 * @hostrcb: hostrcb pointer
1565 * @vpd: vendor/product id/sn/wwn struct
1570 static void ipr_log_ext_vpd_compact(char *prefix
, struct ipr_hostrcb
*hostrcb
,
1571 struct ipr_ext_vpd
*vpd
)
1573 ipr_log_vpd_compact(prefix
, hostrcb
, &vpd
->vpd
);
1574 ipr_hcam_err(hostrcb
, "%s WWN: %08X%08X\n", prefix
,
1575 be32_to_cpu(vpd
->wwid
[0]), be32_to_cpu(vpd
->wwid
[1]));
1579 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1580 * @vpd: vendor/product id/sn/wwn struct
1585 static void ipr_log_ext_vpd(struct ipr_ext_vpd
*vpd
)
1587 ipr_log_vpd(&vpd
->vpd
);
1588 ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd
->wwid
[0]),
1589 be32_to_cpu(vpd
->wwid
[1]));
1593 * ipr_log_enhanced_cache_error - Log a cache error.
1594 * @ioa_cfg: ioa config struct
1595 * @hostrcb: hostrcb struct
1600 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg
*ioa_cfg
,
1601 struct ipr_hostrcb
*hostrcb
)
1603 struct ipr_hostrcb_type_12_error
*error
;
1606 error
= &hostrcb
->hcam
.u
.error64
.u
.type_12_error
;
1608 error
= &hostrcb
->hcam
.u
.error
.u
.type_12_error
;
1610 ipr_err("-----Current Configuration-----\n");
1611 ipr_err("Cache Directory Card Information:\n");
1612 ipr_log_ext_vpd(&error
->ioa_vpd
);
1613 ipr_err("Adapter Card Information:\n");
1614 ipr_log_ext_vpd(&error
->cfc_vpd
);
1616 ipr_err("-----Expected Configuration-----\n");
1617 ipr_err("Cache Directory Card Information:\n");
1618 ipr_log_ext_vpd(&error
->ioa_last_attached_to_cfc_vpd
);
1619 ipr_err("Adapter Card Information:\n");
1620 ipr_log_ext_vpd(&error
->cfc_last_attached_to_ioa_vpd
);
1622 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1623 be32_to_cpu(error
->ioa_data
[0]),
1624 be32_to_cpu(error
->ioa_data
[1]),
1625 be32_to_cpu(error
->ioa_data
[2]));
1629 * ipr_log_cache_error - Log a cache error.
1630 * @ioa_cfg: ioa config struct
1631 * @hostrcb: hostrcb struct
1636 static void ipr_log_cache_error(struct ipr_ioa_cfg
*ioa_cfg
,
1637 struct ipr_hostrcb
*hostrcb
)
1639 struct ipr_hostrcb_type_02_error
*error
=
1640 &hostrcb
->hcam
.u
.error
.u
.type_02_error
;
1642 ipr_err("-----Current Configuration-----\n");
1643 ipr_err("Cache Directory Card Information:\n");
1644 ipr_log_vpd(&error
->ioa_vpd
);
1645 ipr_err("Adapter Card Information:\n");
1646 ipr_log_vpd(&error
->cfc_vpd
);
1648 ipr_err("-----Expected Configuration-----\n");
1649 ipr_err("Cache Directory Card Information:\n");
1650 ipr_log_vpd(&error
->ioa_last_attached_to_cfc_vpd
);
1651 ipr_err("Adapter Card Information:\n");
1652 ipr_log_vpd(&error
->cfc_last_attached_to_ioa_vpd
);
1654 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1655 be32_to_cpu(error
->ioa_data
[0]),
1656 be32_to_cpu(error
->ioa_data
[1]),
1657 be32_to_cpu(error
->ioa_data
[2]));
1661 * ipr_log_enhanced_config_error - Log a configuration error.
1662 * @ioa_cfg: ioa config struct
1663 * @hostrcb: hostrcb struct
1668 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg
*ioa_cfg
,
1669 struct ipr_hostrcb
*hostrcb
)
1671 int errors_logged
, i
;
1672 struct ipr_hostrcb_device_data_entry_enhanced
*dev_entry
;
1673 struct ipr_hostrcb_type_13_error
*error
;
1675 error
= &hostrcb
->hcam
.u
.error
.u
.type_13_error
;
1676 errors_logged
= be32_to_cpu(error
->errors_logged
);
1678 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1679 be32_to_cpu(error
->errors_detected
), errors_logged
);
1681 dev_entry
= error
->dev
;
1683 for (i
= 0; i
< errors_logged
; i
++, dev_entry
++) {
1686 ipr_phys_res_err(ioa_cfg
, dev_entry
->dev_res_addr
, "Device %d", i
+ 1);
1687 ipr_log_ext_vpd(&dev_entry
->vpd
);
1689 ipr_err("-----New Device Information-----\n");
1690 ipr_log_ext_vpd(&dev_entry
->new_vpd
);
1692 ipr_err("Cache Directory Card Information:\n");
1693 ipr_log_ext_vpd(&dev_entry
->ioa_last_with_dev_vpd
);
1695 ipr_err("Adapter Card Information:\n");
1696 ipr_log_ext_vpd(&dev_entry
->cfc_last_with_dev_vpd
);
1701 * ipr_log_sis64_config_error - Log a device error.
1702 * @ioa_cfg: ioa config struct
1703 * @hostrcb: hostrcb struct
1708 static void ipr_log_sis64_config_error(struct ipr_ioa_cfg
*ioa_cfg
,
1709 struct ipr_hostrcb
*hostrcb
)
1711 int errors_logged
, i
;
1712 struct ipr_hostrcb64_device_data_entry_enhanced
*dev_entry
;
1713 struct ipr_hostrcb_type_23_error
*error
;
1714 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
1716 error
= &hostrcb
->hcam
.u
.error64
.u
.type_23_error
;
1717 errors_logged
= be32_to_cpu(error
->errors_logged
);
1719 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1720 be32_to_cpu(error
->errors_detected
), errors_logged
);
1722 dev_entry
= error
->dev
;
1724 for (i
= 0; i
< errors_logged
; i
++, dev_entry
++) {
1727 ipr_err("Device %d : %s", i
+ 1,
1728 __ipr_format_res_path(dev_entry
->res_path
,
1729 buffer
, sizeof(buffer
)));
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_config_error - Log a configuration error.
1745 * @ioa_cfg: ioa config struct
1746 * @hostrcb: hostrcb struct
1751 static void ipr_log_config_error(struct ipr_ioa_cfg
*ioa_cfg
,
1752 struct ipr_hostrcb
*hostrcb
)
1754 int errors_logged
, i
;
1755 struct ipr_hostrcb_device_data_entry
*dev_entry
;
1756 struct ipr_hostrcb_type_03_error
*error
;
1758 error
= &hostrcb
->hcam
.u
.error
.u
.type_03_error
;
1759 errors_logged
= be32_to_cpu(error
->errors_logged
);
1761 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1762 be32_to_cpu(error
->errors_detected
), errors_logged
);
1764 dev_entry
= error
->dev
;
1766 for (i
= 0; i
< errors_logged
; i
++, dev_entry
++) {
1769 ipr_phys_res_err(ioa_cfg
, dev_entry
->dev_res_addr
, "Device %d", i
+ 1);
1770 ipr_log_vpd(&dev_entry
->vpd
);
1772 ipr_err("-----New Device Information-----\n");
1773 ipr_log_vpd(&dev_entry
->new_vpd
);
1775 ipr_err("Cache Directory Card Information:\n");
1776 ipr_log_vpd(&dev_entry
->ioa_last_with_dev_vpd
);
1778 ipr_err("Adapter Card Information:\n");
1779 ipr_log_vpd(&dev_entry
->cfc_last_with_dev_vpd
);
1781 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1782 be32_to_cpu(dev_entry
->ioa_data
[0]),
1783 be32_to_cpu(dev_entry
->ioa_data
[1]),
1784 be32_to_cpu(dev_entry
->ioa_data
[2]),
1785 be32_to_cpu(dev_entry
->ioa_data
[3]),
1786 be32_to_cpu(dev_entry
->ioa_data
[4]));
1791 * ipr_log_enhanced_array_error - Log an array configuration error.
1792 * @ioa_cfg: ioa config struct
1793 * @hostrcb: hostrcb struct
1798 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg
*ioa_cfg
,
1799 struct ipr_hostrcb
*hostrcb
)
1802 struct ipr_hostrcb_type_14_error
*error
;
1803 struct ipr_hostrcb_array_data_entry_enhanced
*array_entry
;
1804 const u8 zero_sn
[IPR_SERIAL_NUM_LEN
] = { [0 ... IPR_SERIAL_NUM_LEN
-1] = '0' };
1806 error
= &hostrcb
->hcam
.u
.error
.u
.type_14_error
;
1810 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1811 error
->protection_level
,
1812 ioa_cfg
->host
->host_no
,
1813 error
->last_func_vset_res_addr
.bus
,
1814 error
->last_func_vset_res_addr
.target
,
1815 error
->last_func_vset_res_addr
.lun
);
1819 array_entry
= error
->array_member
;
1820 num_entries
= min_t(u32
, be32_to_cpu(error
->num_entries
),
1821 ARRAY_SIZE(error
->array_member
));
1823 for (i
= 0; i
< num_entries
; i
++, array_entry
++) {
1824 if (!memcmp(array_entry
->vpd
.vpd
.sn
, zero_sn
, IPR_SERIAL_NUM_LEN
))
1827 if (be32_to_cpu(error
->exposed_mode_adn
) == i
)
1828 ipr_err("Exposed Array Member %d:\n", i
);
1830 ipr_err("Array Member %d:\n", i
);
1832 ipr_log_ext_vpd(&array_entry
->vpd
);
1833 ipr_phys_res_err(ioa_cfg
, array_entry
->dev_res_addr
, "Current Location");
1834 ipr_phys_res_err(ioa_cfg
, array_entry
->expected_dev_res_addr
,
1835 "Expected Location");
1842 * ipr_log_array_error - Log an array configuration error.
1843 * @ioa_cfg: ioa config struct
1844 * @hostrcb: hostrcb struct
1849 static void ipr_log_array_error(struct ipr_ioa_cfg
*ioa_cfg
,
1850 struct ipr_hostrcb
*hostrcb
)
1853 struct ipr_hostrcb_type_04_error
*error
;
1854 struct ipr_hostrcb_array_data_entry
*array_entry
;
1855 const u8 zero_sn
[IPR_SERIAL_NUM_LEN
] = { [0 ... IPR_SERIAL_NUM_LEN
-1] = '0' };
1857 error
= &hostrcb
->hcam
.u
.error
.u
.type_04_error
;
1861 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1862 error
->protection_level
,
1863 ioa_cfg
->host
->host_no
,
1864 error
->last_func_vset_res_addr
.bus
,
1865 error
->last_func_vset_res_addr
.target
,
1866 error
->last_func_vset_res_addr
.lun
);
1870 array_entry
= error
->array_member
;
1872 for (i
= 0; i
< 18; i
++) {
1873 if (!memcmp(array_entry
->vpd
.sn
, zero_sn
, IPR_SERIAL_NUM_LEN
))
1876 if (be32_to_cpu(error
->exposed_mode_adn
) == i
)
1877 ipr_err("Exposed Array Member %d:\n", i
);
1879 ipr_err("Array Member %d:\n", i
);
1881 ipr_log_vpd(&array_entry
->vpd
);
1883 ipr_phys_res_err(ioa_cfg
, array_entry
->dev_res_addr
, "Current Location");
1884 ipr_phys_res_err(ioa_cfg
, array_entry
->expected_dev_res_addr
,
1885 "Expected Location");
1890 array_entry
= error
->array_member2
;
1897 * ipr_log_hex_data - Log additional hex IOA error data.
1898 * @ioa_cfg: ioa config struct
1899 * @data: IOA error data
1905 static void ipr_log_hex_data(struct ipr_ioa_cfg
*ioa_cfg
, __be32
*data
, int len
)
1912 if (ioa_cfg
->log_level
<= IPR_DEFAULT_LOG_LEVEL
)
1913 len
= min_t(int, len
, IPR_DEFAULT_MAX_ERROR_DUMP
);
1915 for (i
= 0; i
< len
/ 4; i
+= 4) {
1916 ipr_err("%08X: %08X %08X %08X %08X\n", i
*4,
1917 be32_to_cpu(data
[i
]),
1918 be32_to_cpu(data
[i
+1]),
1919 be32_to_cpu(data
[i
+2]),
1920 be32_to_cpu(data
[i
+3]));
1925 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1926 * @ioa_cfg: ioa config struct
1927 * @hostrcb: hostrcb struct
1932 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg
*ioa_cfg
,
1933 struct ipr_hostrcb
*hostrcb
)
1935 struct ipr_hostrcb_type_17_error
*error
;
1938 error
= &hostrcb
->hcam
.u
.error64
.u
.type_17_error
;
1940 error
= &hostrcb
->hcam
.u
.error
.u
.type_17_error
;
1942 error
->failure_reason
[sizeof(error
->failure_reason
) - 1] = '\0';
1943 strim(error
->failure_reason
);
1945 ipr_hcam_err(hostrcb
, "%s [PRC: %08X]\n", error
->failure_reason
,
1946 be32_to_cpu(hostrcb
->hcam
.u
.error
.prc
));
1947 ipr_log_ext_vpd_compact("Remote IOA", hostrcb
, &error
->vpd
);
1948 ipr_log_hex_data(ioa_cfg
, error
->data
,
1949 be32_to_cpu(hostrcb
->hcam
.length
) -
1950 (offsetof(struct ipr_hostrcb_error
, u
) +
1951 offsetof(struct ipr_hostrcb_type_17_error
, data
)));
1955 * ipr_log_dual_ioa_error - Log a dual adapter error.
1956 * @ioa_cfg: ioa config struct
1957 * @hostrcb: hostrcb struct
1962 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg
*ioa_cfg
,
1963 struct ipr_hostrcb
*hostrcb
)
1965 struct ipr_hostrcb_type_07_error
*error
;
1967 error
= &hostrcb
->hcam
.u
.error
.u
.type_07_error
;
1968 error
->failure_reason
[sizeof(error
->failure_reason
) - 1] = '\0';
1969 strim(error
->failure_reason
);
1971 ipr_hcam_err(hostrcb
, "%s [PRC: %08X]\n", error
->failure_reason
,
1972 be32_to_cpu(hostrcb
->hcam
.u
.error
.prc
));
1973 ipr_log_vpd_compact("Remote IOA", hostrcb
, &error
->vpd
);
1974 ipr_log_hex_data(ioa_cfg
, error
->data
,
1975 be32_to_cpu(hostrcb
->hcam
.length
) -
1976 (offsetof(struct ipr_hostrcb_error
, u
) +
1977 offsetof(struct ipr_hostrcb_type_07_error
, data
)));
1980 static const struct {
1983 } path_active_desc
[] = {
1984 { IPR_PATH_NO_INFO
, "Path" },
1985 { IPR_PATH_ACTIVE
, "Active path" },
1986 { IPR_PATH_NOT_ACTIVE
, "Inactive path" }
1989 static const struct {
1992 } path_state_desc
[] = {
1993 { IPR_PATH_STATE_NO_INFO
, "has no path state information available" },
1994 { IPR_PATH_HEALTHY
, "is healthy" },
1995 { IPR_PATH_DEGRADED
, "is degraded" },
1996 { IPR_PATH_FAILED
, "is failed" }
2000 * ipr_log_fabric_path - Log a fabric path error
2001 * @hostrcb: hostrcb struct
2002 * @fabric: fabric descriptor
2007 static void ipr_log_fabric_path(struct ipr_hostrcb
*hostrcb
,
2008 struct ipr_hostrcb_fabric_desc
*fabric
)
2011 u8 path_state
= fabric
->path_state
;
2012 u8 active
= path_state
& IPR_PATH_ACTIVE_MASK
;
2013 u8 state
= path_state
& IPR_PATH_STATE_MASK
;
2015 for (i
= 0; i
< ARRAY_SIZE(path_active_desc
); i
++) {
2016 if (path_active_desc
[i
].active
!= active
)
2019 for (j
= 0; j
< ARRAY_SIZE(path_state_desc
); j
++) {
2020 if (path_state_desc
[j
].state
!= state
)
2023 if (fabric
->cascaded_expander
== 0xff && fabric
->phy
== 0xff) {
2024 ipr_hcam_err(hostrcb
, "%s %s: IOA Port=%d\n",
2025 path_active_desc
[i
].desc
, path_state_desc
[j
].desc
,
2027 } else if (fabric
->cascaded_expander
== 0xff) {
2028 ipr_hcam_err(hostrcb
, "%s %s: IOA Port=%d, Phy=%d\n",
2029 path_active_desc
[i
].desc
, path_state_desc
[j
].desc
,
2030 fabric
->ioa_port
, fabric
->phy
);
2031 } else if (fabric
->phy
== 0xff) {
2032 ipr_hcam_err(hostrcb
, "%s %s: IOA Port=%d, Cascade=%d\n",
2033 path_active_desc
[i
].desc
, path_state_desc
[j
].desc
,
2034 fabric
->ioa_port
, fabric
->cascaded_expander
);
2036 ipr_hcam_err(hostrcb
, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
2037 path_active_desc
[i
].desc
, path_state_desc
[j
].desc
,
2038 fabric
->ioa_port
, fabric
->cascaded_expander
, fabric
->phy
);
2044 ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state
,
2045 fabric
->ioa_port
, fabric
->cascaded_expander
, fabric
->phy
);
2049 * ipr_log64_fabric_path - Log a fabric path error
2050 * @hostrcb: hostrcb struct
2051 * @fabric: fabric descriptor
2056 static void ipr_log64_fabric_path(struct ipr_hostrcb
*hostrcb
,
2057 struct ipr_hostrcb64_fabric_desc
*fabric
)
2060 u8 path_state
= fabric
->path_state
;
2061 u8 active
= path_state
& IPR_PATH_ACTIVE_MASK
;
2062 u8 state
= path_state
& IPR_PATH_STATE_MASK
;
2063 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
2065 for (i
= 0; i
< ARRAY_SIZE(path_active_desc
); i
++) {
2066 if (path_active_desc
[i
].active
!= active
)
2069 for (j
= 0; j
< ARRAY_SIZE(path_state_desc
); j
++) {
2070 if (path_state_desc
[j
].state
!= state
)
2073 ipr_hcam_err(hostrcb
, "%s %s: Resource Path=%s\n",
2074 path_active_desc
[i
].desc
, path_state_desc
[j
].desc
,
2075 ipr_format_res_path(hostrcb
->ioa_cfg
,
2077 buffer
, sizeof(buffer
)));
2082 ipr_err("Path state=%02X Resource Path=%s\n", path_state
,
2083 ipr_format_res_path(hostrcb
->ioa_cfg
, fabric
->res_path
,
2084 buffer
, sizeof(buffer
)));
2087 static const struct {
2090 } path_type_desc
[] = {
2091 { IPR_PATH_CFG_IOA_PORT
, "IOA port" },
2092 { IPR_PATH_CFG_EXP_PORT
, "Expander port" },
2093 { IPR_PATH_CFG_DEVICE_PORT
, "Device port" },
2094 { IPR_PATH_CFG_DEVICE_LUN
, "Device LUN" }
2097 static const struct {
2100 } path_status_desc
[] = {
2101 { IPR_PATH_CFG_NO_PROB
, "Functional" },
2102 { IPR_PATH_CFG_DEGRADED
, "Degraded" },
2103 { IPR_PATH_CFG_FAILED
, "Failed" },
2104 { IPR_PATH_CFG_SUSPECT
, "Suspect" },
2105 { IPR_PATH_NOT_DETECTED
, "Missing" },
2106 { IPR_PATH_INCORRECT_CONN
, "Incorrectly connected" }
2109 static const char *link_rate
[] = {
2112 "phy reset problem",
2129 * ipr_log_path_elem - Log a fabric path element.
2130 * @hostrcb: hostrcb struct
2131 * @cfg: fabric path element struct
2136 static void ipr_log_path_elem(struct ipr_hostrcb
*hostrcb
,
2137 struct ipr_hostrcb_config_element
*cfg
)
2140 u8 type
= cfg
->type_status
& IPR_PATH_CFG_TYPE_MASK
;
2141 u8 status
= cfg
->type_status
& IPR_PATH_CFG_STATUS_MASK
;
2143 if (type
== IPR_PATH_CFG_NOT_EXIST
)
2146 for (i
= 0; i
< ARRAY_SIZE(path_type_desc
); i
++) {
2147 if (path_type_desc
[i
].type
!= type
)
2150 for (j
= 0; j
< ARRAY_SIZE(path_status_desc
); j
++) {
2151 if (path_status_desc
[j
].status
!= status
)
2154 if (type
== IPR_PATH_CFG_IOA_PORT
) {
2155 ipr_hcam_err(hostrcb
, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2156 path_status_desc
[j
].desc
, path_type_desc
[i
].desc
,
2157 cfg
->phy
, link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2158 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2160 if (cfg
->cascaded_expander
== 0xff && cfg
->phy
== 0xff) {
2161 ipr_hcam_err(hostrcb
, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2162 path_status_desc
[j
].desc
, path_type_desc
[i
].desc
,
2163 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2164 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2165 } else if (cfg
->cascaded_expander
== 0xff) {
2166 ipr_hcam_err(hostrcb
, "%s %s: Phy=%d, Link rate=%s, "
2167 "WWN=%08X%08X\n", path_status_desc
[j
].desc
,
2168 path_type_desc
[i
].desc
, cfg
->phy
,
2169 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2170 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2171 } else if (cfg
->phy
== 0xff) {
2172 ipr_hcam_err(hostrcb
, "%s %s: Cascade=%d, Link rate=%s, "
2173 "WWN=%08X%08X\n", path_status_desc
[j
].desc
,
2174 path_type_desc
[i
].desc
, cfg
->cascaded_expander
,
2175 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2176 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2178 ipr_hcam_err(hostrcb
, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2179 "WWN=%08X%08X\n", path_status_desc
[j
].desc
,
2180 path_type_desc
[i
].desc
, cfg
->cascaded_expander
, cfg
->phy
,
2181 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2182 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2189 ipr_hcam_err(hostrcb
, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2190 "WWN=%08X%08X\n", cfg
->type_status
, cfg
->cascaded_expander
, cfg
->phy
,
2191 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2192 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2196 * ipr_log64_path_elem - Log a fabric path element.
2197 * @hostrcb: hostrcb struct
2198 * @cfg: fabric path element struct
2203 static void ipr_log64_path_elem(struct ipr_hostrcb
*hostrcb
,
2204 struct ipr_hostrcb64_config_element
*cfg
)
2207 u8 desc_id
= cfg
->descriptor_id
& IPR_DESCRIPTOR_MASK
;
2208 u8 type
= cfg
->type_status
& IPR_PATH_CFG_TYPE_MASK
;
2209 u8 status
= cfg
->type_status
& IPR_PATH_CFG_STATUS_MASK
;
2210 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
2212 if (type
== IPR_PATH_CFG_NOT_EXIST
|| desc_id
!= IPR_DESCRIPTOR_SIS64
)
2215 for (i
= 0; i
< ARRAY_SIZE(path_type_desc
); i
++) {
2216 if (path_type_desc
[i
].type
!= type
)
2219 for (j
= 0; j
< ARRAY_SIZE(path_status_desc
); j
++) {
2220 if (path_status_desc
[j
].status
!= status
)
2223 ipr_hcam_err(hostrcb
, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2224 path_status_desc
[j
].desc
, path_type_desc
[i
].desc
,
2225 ipr_format_res_path(hostrcb
->ioa_cfg
,
2226 cfg
->res_path
, buffer
, sizeof(buffer
)),
2227 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2228 be32_to_cpu(cfg
->wwid
[0]),
2229 be32_to_cpu(cfg
->wwid
[1]));
2233 ipr_hcam_err(hostrcb
, "Path element=%02X: Resource Path=%s, Link rate=%s "
2234 "WWN=%08X%08X\n", cfg
->type_status
,
2235 ipr_format_res_path(hostrcb
->ioa_cfg
,
2236 cfg
->res_path
, buffer
, sizeof(buffer
)),
2237 link_rate
[cfg
->link_rate
& IPR_PHY_LINK_RATE_MASK
],
2238 be32_to_cpu(cfg
->wwid
[0]), be32_to_cpu(cfg
->wwid
[1]));
2242 * ipr_log_fabric_error - Log a fabric error.
2243 * @ioa_cfg: ioa config struct
2244 * @hostrcb: hostrcb struct
2249 static void ipr_log_fabric_error(struct ipr_ioa_cfg
*ioa_cfg
,
2250 struct ipr_hostrcb
*hostrcb
)
2252 struct ipr_hostrcb_type_20_error
*error
;
2253 struct ipr_hostrcb_fabric_desc
*fabric
;
2254 struct ipr_hostrcb_config_element
*cfg
;
2257 error
= &hostrcb
->hcam
.u
.error
.u
.type_20_error
;
2258 error
->failure_reason
[sizeof(error
->failure_reason
) - 1] = '\0';
2259 ipr_hcam_err(hostrcb
, "%s\n", error
->failure_reason
);
2261 add_len
= be32_to_cpu(hostrcb
->hcam
.length
) -
2262 (offsetof(struct ipr_hostrcb_error
, u
) +
2263 offsetof(struct ipr_hostrcb_type_20_error
, desc
));
2265 for (i
= 0, fabric
= error
->desc
; i
< error
->num_entries
; i
++) {
2266 ipr_log_fabric_path(hostrcb
, fabric
);
2267 for_each_fabric_cfg(fabric
, cfg
)
2268 ipr_log_path_elem(hostrcb
, cfg
);
2270 add_len
-= be16_to_cpu(fabric
->length
);
2271 fabric
= (struct ipr_hostrcb_fabric_desc
*)
2272 ((unsigned long)fabric
+ be16_to_cpu(fabric
->length
));
2275 ipr_log_hex_data(ioa_cfg
, (__be32
*)fabric
, add_len
);
2279 * ipr_log_sis64_array_error - Log a sis64 array error.
2280 * @ioa_cfg: ioa config struct
2281 * @hostrcb: hostrcb struct
2286 static void ipr_log_sis64_array_error(struct ipr_ioa_cfg
*ioa_cfg
,
2287 struct ipr_hostrcb
*hostrcb
)
2290 struct ipr_hostrcb_type_24_error
*error
;
2291 struct ipr_hostrcb64_array_data_entry
*array_entry
;
2292 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
2293 const u8 zero_sn
[IPR_SERIAL_NUM_LEN
] = { [0 ... IPR_SERIAL_NUM_LEN
-1] = '0' };
2295 error
= &hostrcb
->hcam
.u
.error64
.u
.type_24_error
;
2299 ipr_err("RAID %s Array Configuration: %s\n",
2300 error
->protection_level
,
2301 ipr_format_res_path(ioa_cfg
, error
->last_res_path
,
2302 buffer
, sizeof(buffer
)));
2306 array_entry
= error
->array_member
;
2307 num_entries
= min_t(u32
, error
->num_entries
,
2308 ARRAY_SIZE(error
->array_member
));
2310 for (i
= 0; i
< num_entries
; i
++, array_entry
++) {
2312 if (!memcmp(array_entry
->vpd
.vpd
.sn
, zero_sn
, IPR_SERIAL_NUM_LEN
))
2315 if (error
->exposed_mode_adn
== i
)
2316 ipr_err("Exposed Array Member %d:\n", i
);
2318 ipr_err("Array Member %d:\n", i
);
2320 ipr_err("Array Member %d:\n", i
);
2321 ipr_log_ext_vpd(&array_entry
->vpd
);
2322 ipr_err("Current Location: %s\n",
2323 ipr_format_res_path(ioa_cfg
, array_entry
->res_path
,
2324 buffer
, sizeof(buffer
)));
2325 ipr_err("Expected Location: %s\n",
2326 ipr_format_res_path(ioa_cfg
,
2327 array_entry
->expected_res_path
,
2328 buffer
, sizeof(buffer
)));
2335 * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2336 * @ioa_cfg: ioa config struct
2337 * @hostrcb: hostrcb struct
2342 static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg
*ioa_cfg
,
2343 struct ipr_hostrcb
*hostrcb
)
2345 struct ipr_hostrcb_type_30_error
*error
;
2346 struct ipr_hostrcb64_fabric_desc
*fabric
;
2347 struct ipr_hostrcb64_config_element
*cfg
;
2350 error
= &hostrcb
->hcam
.u
.error64
.u
.type_30_error
;
2352 error
->failure_reason
[sizeof(error
->failure_reason
) - 1] = '\0';
2353 ipr_hcam_err(hostrcb
, "%s\n", error
->failure_reason
);
2355 add_len
= be32_to_cpu(hostrcb
->hcam
.length
) -
2356 (offsetof(struct ipr_hostrcb64_error
, u
) +
2357 offsetof(struct ipr_hostrcb_type_30_error
, desc
));
2359 for (i
= 0, fabric
= error
->desc
; i
< error
->num_entries
; i
++) {
2360 ipr_log64_fabric_path(hostrcb
, fabric
);
2361 for_each_fabric_cfg(fabric
, cfg
)
2362 ipr_log64_path_elem(hostrcb
, cfg
);
2364 add_len
-= be16_to_cpu(fabric
->length
);
2365 fabric
= (struct ipr_hostrcb64_fabric_desc
*)
2366 ((unsigned long)fabric
+ be16_to_cpu(fabric
->length
));
2369 ipr_log_hex_data(ioa_cfg
, (__be32
*)fabric
, add_len
);
2373 * ipr_log_generic_error - Log an adapter error.
2374 * @ioa_cfg: ioa config struct
2375 * @hostrcb: hostrcb struct
2380 static void ipr_log_generic_error(struct ipr_ioa_cfg
*ioa_cfg
,
2381 struct ipr_hostrcb
*hostrcb
)
2383 ipr_log_hex_data(ioa_cfg
, hostrcb
->hcam
.u
.raw
.data
,
2384 be32_to_cpu(hostrcb
->hcam
.length
));
2388 * ipr_log_sis64_device_error - Log a cache error.
2389 * @ioa_cfg: ioa config struct
2390 * @hostrcb: hostrcb struct
2395 static void ipr_log_sis64_device_error(struct ipr_ioa_cfg
*ioa_cfg
,
2396 struct ipr_hostrcb
*hostrcb
)
2398 struct ipr_hostrcb_type_21_error
*error
;
2399 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
2401 error
= &hostrcb
->hcam
.u
.error64
.u
.type_21_error
;
2403 ipr_err("-----Failing Device Information-----\n");
2404 ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
2405 be32_to_cpu(error
->wwn
[0]), be32_to_cpu(error
->wwn
[1]),
2406 be32_to_cpu(error
->wwn
[2]), be32_to_cpu(error
->wwn
[3]));
2407 ipr_err("Device Resource Path: %s\n",
2408 __ipr_format_res_path(error
->res_path
,
2409 buffer
, sizeof(buffer
)));
2410 error
->primary_problem_desc
[sizeof(error
->primary_problem_desc
) - 1] = '\0';
2411 error
->second_problem_desc
[sizeof(error
->second_problem_desc
) - 1] = '\0';
2412 ipr_err("Primary Problem Description: %s\n", error
->primary_problem_desc
);
2413 ipr_err("Secondary Problem Description: %s\n", error
->second_problem_desc
);
2414 ipr_err("SCSI Sense Data:\n");
2415 ipr_log_hex_data(ioa_cfg
, error
->sense_data
, sizeof(error
->sense_data
));
2416 ipr_err("SCSI Command Descriptor Block: \n");
2417 ipr_log_hex_data(ioa_cfg
, error
->cdb
, sizeof(error
->cdb
));
2419 ipr_err("Additional IOA Data:\n");
2420 ipr_log_hex_data(ioa_cfg
, error
->ioa_data
, be32_to_cpu(error
->length_of_error
));
2424 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2427 * This function will return the index of into the ipr_error_table
2428 * for the specified IOASC. If the IOASC is not in the table,
2429 * 0 will be returned, which points to the entry used for unknown errors.
2432 * index into the ipr_error_table
2434 static u32
ipr_get_error(u32 ioasc
)
2438 for (i
= 0; i
< ARRAY_SIZE(ipr_error_table
); i
++)
2439 if (ipr_error_table
[i
].ioasc
== (ioasc
& IPR_IOASC_IOASC_MASK
))
2446 * ipr_handle_log_data - Log an adapter error.
2447 * @ioa_cfg: ioa config struct
2448 * @hostrcb: hostrcb struct
2450 * This function logs an adapter error to the system.
2455 static void ipr_handle_log_data(struct ipr_ioa_cfg
*ioa_cfg
,
2456 struct ipr_hostrcb
*hostrcb
)
2460 struct ipr_hostrcb_type_21_error
*error
;
2462 if (hostrcb
->hcam
.notify_type
!= IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY
)
2465 if (hostrcb
->hcam
.notifications_lost
== IPR_HOST_RCB_NOTIFICATIONS_LOST
)
2466 dev_err(&ioa_cfg
->pdev
->dev
, "Error notifications lost\n");
2469 ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error64
.fd_ioasc
);
2471 ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error
.fd_ioasc
);
2473 if (!ioa_cfg
->sis64
&& (ioasc
== IPR_IOASC_BUS_WAS_RESET
||
2474 ioasc
== IPR_IOASC_BUS_WAS_RESET_BY_OTHER
)) {
2475 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2476 scsi_report_bus_reset(ioa_cfg
->host
,
2477 hostrcb
->hcam
.u
.error
.fd_res_addr
.bus
);
2480 error_index
= ipr_get_error(ioasc
);
2482 if (!ipr_error_table
[error_index
].log_hcam
)
2485 if (ioasc
== IPR_IOASC_HW_CMD_FAILED
&&
2486 hostrcb
->hcam
.overlay_id
== IPR_HOST_RCB_OVERLAY_ID_21
) {
2487 error
= &hostrcb
->hcam
.u
.error64
.u
.type_21_error
;
2489 if (((be32_to_cpu(error
->sense_data
[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST
&&
2490 ioa_cfg
->log_level
<= IPR_DEFAULT_LOG_LEVEL
)
2494 ipr_hcam_err(hostrcb
, "%s\n", ipr_error_table
[error_index
].error
);
2496 /* Set indication we have logged an error */
2497 ioa_cfg
->errors_logged
++;
2499 if (ioa_cfg
->log_level
< ipr_error_table
[error_index
].log_hcam
)
2501 if (be32_to_cpu(hostrcb
->hcam
.length
) > sizeof(hostrcb
->hcam
.u
.raw
))
2502 hostrcb
->hcam
.length
= cpu_to_be32(sizeof(hostrcb
->hcam
.u
.raw
));
2504 switch (hostrcb
->hcam
.overlay_id
) {
2505 case IPR_HOST_RCB_OVERLAY_ID_2
:
2506 ipr_log_cache_error(ioa_cfg
, hostrcb
);
2508 case IPR_HOST_RCB_OVERLAY_ID_3
:
2509 ipr_log_config_error(ioa_cfg
, hostrcb
);
2511 case IPR_HOST_RCB_OVERLAY_ID_4
:
2512 case IPR_HOST_RCB_OVERLAY_ID_6
:
2513 ipr_log_array_error(ioa_cfg
, hostrcb
);
2515 case IPR_HOST_RCB_OVERLAY_ID_7
:
2516 ipr_log_dual_ioa_error(ioa_cfg
, hostrcb
);
2518 case IPR_HOST_RCB_OVERLAY_ID_12
:
2519 ipr_log_enhanced_cache_error(ioa_cfg
, hostrcb
);
2521 case IPR_HOST_RCB_OVERLAY_ID_13
:
2522 ipr_log_enhanced_config_error(ioa_cfg
, hostrcb
);
2524 case IPR_HOST_RCB_OVERLAY_ID_14
:
2525 case IPR_HOST_RCB_OVERLAY_ID_16
:
2526 ipr_log_enhanced_array_error(ioa_cfg
, hostrcb
);
2528 case IPR_HOST_RCB_OVERLAY_ID_17
:
2529 ipr_log_enhanced_dual_ioa_error(ioa_cfg
, hostrcb
);
2531 case IPR_HOST_RCB_OVERLAY_ID_20
:
2532 ipr_log_fabric_error(ioa_cfg
, hostrcb
);
2534 case IPR_HOST_RCB_OVERLAY_ID_21
:
2535 ipr_log_sis64_device_error(ioa_cfg
, hostrcb
);
2537 case IPR_HOST_RCB_OVERLAY_ID_23
:
2538 ipr_log_sis64_config_error(ioa_cfg
, hostrcb
);
2540 case IPR_HOST_RCB_OVERLAY_ID_24
:
2541 case IPR_HOST_RCB_OVERLAY_ID_26
:
2542 ipr_log_sis64_array_error(ioa_cfg
, hostrcb
);
2544 case IPR_HOST_RCB_OVERLAY_ID_30
:
2545 ipr_log_sis64_fabric_error(ioa_cfg
, hostrcb
);
2547 case IPR_HOST_RCB_OVERLAY_ID_1
:
2548 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT
:
2550 ipr_log_generic_error(ioa_cfg
, hostrcb
);
2556 * ipr_process_error - Op done function for an adapter error log.
2557 * @ipr_cmd: ipr command struct
2559 * This function is the op done function for an error log host
2560 * controlled async from the adapter. It will log the error and
2561 * send the HCAM back to the adapter.
2566 static void ipr_process_error(struct ipr_cmnd
*ipr_cmd
)
2568 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
2569 struct ipr_hostrcb
*hostrcb
= ipr_cmd
->u
.hostrcb
;
2570 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
2574 fd_ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error64
.fd_ioasc
);
2576 fd_ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error
.fd_ioasc
);
2578 list_del(&hostrcb
->queue
);
2579 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
2582 ipr_handle_log_data(ioa_cfg
, hostrcb
);
2583 if (fd_ioasc
== IPR_IOASC_NR_IOA_RESET_REQUIRED
)
2584 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_ABBREV
);
2585 } else if (ioasc
!= IPR_IOASC_IOA_WAS_RESET
&&
2586 ioasc
!= IPR_IOASC_ABORTED_CMD_TERM_BY_HOST
) {
2587 dev_err(&ioa_cfg
->pdev
->dev
,
2588 "Host RCB failed with IOASC: 0x%08X\n", ioasc
);
2591 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_LOG_DATA
, hostrcb
);
2595 * ipr_timeout - An internally generated op has timed out.
2596 * @ipr_cmd: ipr command struct
2598 * This function blocks host requests and initiates an
2604 static void ipr_timeout(struct ipr_cmnd
*ipr_cmd
)
2606 unsigned long lock_flags
= 0;
2607 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
2610 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
2612 ioa_cfg
->errors_logged
++;
2613 dev_err(&ioa_cfg
->pdev
->dev
,
2614 "Adapter being reset due to command timeout.\n");
2616 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
2617 ioa_cfg
->sdt_state
= GET_DUMP
;
2619 if (!ioa_cfg
->in_reset_reload
|| ioa_cfg
->reset_cmd
== ipr_cmd
)
2620 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
2622 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
2627 * ipr_oper_timeout - Adapter timed out transitioning to operational
2628 * @ipr_cmd: ipr command struct
2630 * This function blocks host requests and initiates an
2636 static void ipr_oper_timeout(struct ipr_cmnd
*ipr_cmd
)
2638 unsigned long lock_flags
= 0;
2639 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
2642 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
2644 ioa_cfg
->errors_logged
++;
2645 dev_err(&ioa_cfg
->pdev
->dev
,
2646 "Adapter timed out transitioning to operational.\n");
2648 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
2649 ioa_cfg
->sdt_state
= GET_DUMP
;
2651 if (!ioa_cfg
->in_reset_reload
|| ioa_cfg
->reset_cmd
== ipr_cmd
) {
2653 ioa_cfg
->reset_retries
+= IPR_NUM_RESET_RELOAD_RETRIES
;
2654 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
2657 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
2662 * ipr_find_ses_entry - Find matching SES in SES table
2663 * @res: resource entry struct of SES
2666 * pointer to SES table entry / NULL on failure
2668 static const struct ipr_ses_table_entry
*
2669 ipr_find_ses_entry(struct ipr_resource_entry
*res
)
2672 struct ipr_std_inq_vpids
*vpids
;
2673 const struct ipr_ses_table_entry
*ste
= ipr_ses_table
;
2675 for (i
= 0; i
< ARRAY_SIZE(ipr_ses_table
); i
++, ste
++) {
2676 for (j
= 0, matches
= 0; j
< IPR_PROD_ID_LEN
; j
++) {
2677 if (ste
->compare_product_id_byte
[j
] == 'X') {
2678 vpids
= &res
->std_inq_data
.vpids
;
2679 if (vpids
->product_id
[j
] == ste
->product_id
[j
])
2687 if (matches
== IPR_PROD_ID_LEN
)
2695 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2696 * @ioa_cfg: ioa config struct
2698 * @bus_width: bus width
2701 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2702 * For a 2-byte wide SCSI bus, the maximum transfer speed is
2703 * twice the maximum transfer rate (e.g. for a wide enabled bus,
2704 * max 160MHz = max 320MB/sec).
2706 static u32
ipr_get_max_scsi_speed(struct ipr_ioa_cfg
*ioa_cfg
, u8 bus
, u8 bus_width
)
2708 struct ipr_resource_entry
*res
;
2709 const struct ipr_ses_table_entry
*ste
;
2710 u32 max_xfer_rate
= IPR_MAX_SCSI_RATE(bus_width
);
2712 /* Loop through each config table entry in the config table buffer */
2713 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
2714 if (!(IPR_IS_SES_DEVICE(res
->std_inq_data
)))
2717 if (bus
!= res
->bus
)
2720 if (!(ste
= ipr_find_ses_entry(res
)))
2723 max_xfer_rate
= (ste
->max_bus_speed_limit
* 10) / (bus_width
/ 8);
2726 return max_xfer_rate
;
2730 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2731 * @ioa_cfg: ioa config struct
2732 * @max_delay: max delay in micro-seconds to wait
2734 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2737 * 0 on success / other on failure
2739 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg
*ioa_cfg
, int max_delay
)
2741 volatile u32 pcii_reg
;
2744 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2745 while (delay
< max_delay
) {
2746 pcii_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
2748 if (pcii_reg
& IPR_PCII_IO_DEBUG_ACKNOWLEDGE
)
2751 /* udelay cannot be used if delay is more than a few milliseconds */
2752 if ((delay
/ 1000) > MAX_UDELAY_MS
)
2753 mdelay(delay
/ 1000);
2763 * ipr_get_sis64_dump_data_section - Dump IOA memory
2764 * @ioa_cfg: ioa config struct
2765 * @start_addr: adapter address to dump
2766 * @dest: destination kernel buffer
2767 * @length_in_words: length to dump in 4 byte words
2772 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg
*ioa_cfg
,
2774 __be32
*dest
, u32 length_in_words
)
2778 for (i
= 0; i
< length_in_words
; i
++) {
2779 writel(start_addr
+(i
*4), ioa_cfg
->regs
.dump_addr_reg
);
2780 *dest
= cpu_to_be32(readl(ioa_cfg
->regs
.dump_data_reg
));
2788 * ipr_get_ldump_data_section - Dump IOA memory
2789 * @ioa_cfg: ioa config struct
2790 * @start_addr: adapter address to dump
2791 * @dest: destination kernel buffer
2792 * @length_in_words: length to dump in 4 byte words
2795 * 0 on success / -EIO on failure
2797 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg
*ioa_cfg
,
2799 __be32
*dest
, u32 length_in_words
)
2801 volatile u32 temp_pcii_reg
;
2805 return ipr_get_sis64_dump_data_section(ioa_cfg
, start_addr
,
2806 dest
, length_in_words
);
2808 /* Write IOA interrupt reg starting LDUMP state */
2809 writel((IPR_UPROCI_RESET_ALERT
| IPR_UPROCI_IO_DEBUG_ALERT
),
2810 ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
2812 /* Wait for IO debug acknowledge */
2813 if (ipr_wait_iodbg_ack(ioa_cfg
,
2814 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC
)) {
2815 dev_err(&ioa_cfg
->pdev
->dev
,
2816 "IOA dump long data transfer timeout\n");
2820 /* Signal LDUMP interlocked - clear IO debug ack */
2821 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
,
2822 ioa_cfg
->regs
.clr_interrupt_reg
);
2824 /* Write Mailbox with starting address */
2825 writel(start_addr
, ioa_cfg
->ioa_mailbox
);
2827 /* Signal address valid - clear IOA Reset alert */
2828 writel(IPR_UPROCI_RESET_ALERT
,
2829 ioa_cfg
->regs
.clr_uproc_interrupt_reg32
);
2831 for (i
= 0; i
< length_in_words
; i
++) {
2832 /* Wait for IO debug acknowledge */
2833 if (ipr_wait_iodbg_ack(ioa_cfg
,
2834 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC
)) {
2835 dev_err(&ioa_cfg
->pdev
->dev
,
2836 "IOA dump short data transfer timeout\n");
2840 /* Read data from mailbox and increment destination pointer */
2841 *dest
= cpu_to_be32(readl(ioa_cfg
->ioa_mailbox
));
2844 /* For all but the last word of data, signal data received */
2845 if (i
< (length_in_words
- 1)) {
2846 /* Signal dump data received - Clear IO debug Ack */
2847 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
,
2848 ioa_cfg
->regs
.clr_interrupt_reg
);
2852 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2853 writel(IPR_UPROCI_RESET_ALERT
,
2854 ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
2856 writel(IPR_UPROCI_IO_DEBUG_ALERT
,
2857 ioa_cfg
->regs
.clr_uproc_interrupt_reg32
);
2859 /* Signal dump data received - Clear IO debug Ack */
2860 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
,
2861 ioa_cfg
->regs
.clr_interrupt_reg
);
2863 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2864 while (delay
< IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC
) {
2866 readl(ioa_cfg
->regs
.sense_uproc_interrupt_reg32
);
2868 if (!(temp_pcii_reg
& IPR_UPROCI_RESET_ALERT
))
2878 #ifdef CONFIG_SCSI_IPR_DUMP
2880 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2881 * @ioa_cfg: ioa config struct
2882 * @pci_address: adapter address
2883 * @length: length of data to copy
2885 * Copy data from PCI adapter to kernel buffer.
2886 * Note: length MUST be a 4 byte multiple
2888 * 0 on success / other on failure
2890 static int ipr_sdt_copy(struct ipr_ioa_cfg
*ioa_cfg
,
2891 unsigned long pci_address
, u32 length
)
2893 int bytes_copied
= 0;
2894 int cur_len
, rc
, rem_len
, rem_page_len
, max_dump_size
;
2896 unsigned long lock_flags
= 0;
2897 struct ipr_ioa_dump
*ioa_dump
= &ioa_cfg
->dump
->ioa_dump
;
2900 max_dump_size
= IPR_FMT3_MAX_IOA_DUMP_SIZE
;
2902 max_dump_size
= IPR_FMT2_MAX_IOA_DUMP_SIZE
;
2904 while (bytes_copied
< length
&&
2905 (ioa_dump
->hdr
.len
+ bytes_copied
) < max_dump_size
) {
2906 if (ioa_dump
->page_offset
>= PAGE_SIZE
||
2907 ioa_dump
->page_offset
== 0) {
2908 page
= (__be32
*)__get_free_page(GFP_ATOMIC
);
2912 return bytes_copied
;
2915 ioa_dump
->page_offset
= 0;
2916 ioa_dump
->ioa_data
[ioa_dump
->next_page_index
] = page
;
2917 ioa_dump
->next_page_index
++;
2919 page
= ioa_dump
->ioa_data
[ioa_dump
->next_page_index
- 1];
2921 rem_len
= length
- bytes_copied
;
2922 rem_page_len
= PAGE_SIZE
- ioa_dump
->page_offset
;
2923 cur_len
= min(rem_len
, rem_page_len
);
2925 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
2926 if (ioa_cfg
->sdt_state
== ABORT_DUMP
) {
2929 rc
= ipr_get_ldump_data_section(ioa_cfg
,
2930 pci_address
+ bytes_copied
,
2931 &page
[ioa_dump
->page_offset
/ 4],
2932 (cur_len
/ sizeof(u32
)));
2934 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
2937 ioa_dump
->page_offset
+= cur_len
;
2938 bytes_copied
+= cur_len
;
2946 return bytes_copied
;
2950 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
2951 * @hdr: dump entry header struct
2956 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header
*hdr
)
2958 hdr
->eye_catcher
= IPR_DUMP_EYE_CATCHER
;
2960 hdr
->offset
= sizeof(*hdr
);
2961 hdr
->status
= IPR_DUMP_STATUS_SUCCESS
;
2965 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
2966 * @ioa_cfg: ioa config struct
2967 * @driver_dump: driver dump struct
2972 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg
*ioa_cfg
,
2973 struct ipr_driver_dump
*driver_dump
)
2975 struct ipr_inquiry_page3
*ucode_vpd
= &ioa_cfg
->vpd_cbs
->page3_data
;
2977 ipr_init_dump_entry_hdr(&driver_dump
->ioa_type_entry
.hdr
);
2978 driver_dump
->ioa_type_entry
.hdr
.len
=
2979 sizeof(struct ipr_dump_ioa_type_entry
) -
2980 sizeof(struct ipr_dump_entry_header
);
2981 driver_dump
->ioa_type_entry
.hdr
.data_type
= IPR_DUMP_DATA_TYPE_BINARY
;
2982 driver_dump
->ioa_type_entry
.hdr
.id
= IPR_DUMP_DRIVER_TYPE_ID
;
2983 driver_dump
->ioa_type_entry
.type
= ioa_cfg
->type
;
2984 driver_dump
->ioa_type_entry
.fw_version
= (ucode_vpd
->major_release
<< 24) |
2985 (ucode_vpd
->card_type
<< 16) | (ucode_vpd
->minor_release
[0] << 8) |
2986 ucode_vpd
->minor_release
[1];
2987 driver_dump
->hdr
.num_entries
++;
2991 * ipr_dump_version_data - Fill in the driver version in the dump.
2992 * @ioa_cfg: ioa config struct
2993 * @driver_dump: driver dump struct
2998 static void ipr_dump_version_data(struct ipr_ioa_cfg
*ioa_cfg
,
2999 struct ipr_driver_dump
*driver_dump
)
3001 ipr_init_dump_entry_hdr(&driver_dump
->version_entry
.hdr
);
3002 driver_dump
->version_entry
.hdr
.len
=
3003 sizeof(struct ipr_dump_version_entry
) -
3004 sizeof(struct ipr_dump_entry_header
);
3005 driver_dump
->version_entry
.hdr
.data_type
= IPR_DUMP_DATA_TYPE_ASCII
;
3006 driver_dump
->version_entry
.hdr
.id
= IPR_DUMP_DRIVER_VERSION_ID
;
3007 strcpy(driver_dump
->version_entry
.version
, IPR_DRIVER_VERSION
);
3008 driver_dump
->hdr
.num_entries
++;
3012 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
3013 * @ioa_cfg: ioa config struct
3014 * @driver_dump: driver dump struct
3019 static void ipr_dump_trace_data(struct ipr_ioa_cfg
*ioa_cfg
,
3020 struct ipr_driver_dump
*driver_dump
)
3022 ipr_init_dump_entry_hdr(&driver_dump
->trace_entry
.hdr
);
3023 driver_dump
->trace_entry
.hdr
.len
=
3024 sizeof(struct ipr_dump_trace_entry
) -
3025 sizeof(struct ipr_dump_entry_header
);
3026 driver_dump
->trace_entry
.hdr
.data_type
= IPR_DUMP_DATA_TYPE_BINARY
;
3027 driver_dump
->trace_entry
.hdr
.id
= IPR_DUMP_TRACE_ID
;
3028 memcpy(driver_dump
->trace_entry
.trace
, ioa_cfg
->trace
, IPR_TRACE_SIZE
);
3029 driver_dump
->hdr
.num_entries
++;
3033 * ipr_dump_location_data - Fill in the IOA location in the dump.
3034 * @ioa_cfg: ioa config struct
3035 * @driver_dump: driver dump struct
3040 static void ipr_dump_location_data(struct ipr_ioa_cfg
*ioa_cfg
,
3041 struct ipr_driver_dump
*driver_dump
)
3043 ipr_init_dump_entry_hdr(&driver_dump
->location_entry
.hdr
);
3044 driver_dump
->location_entry
.hdr
.len
=
3045 sizeof(struct ipr_dump_location_entry
) -
3046 sizeof(struct ipr_dump_entry_header
);
3047 driver_dump
->location_entry
.hdr
.data_type
= IPR_DUMP_DATA_TYPE_ASCII
;
3048 driver_dump
->location_entry
.hdr
.id
= IPR_DUMP_LOCATION_ID
;
3049 strcpy(driver_dump
->location_entry
.location
, dev_name(&ioa_cfg
->pdev
->dev
));
3050 driver_dump
->hdr
.num_entries
++;
3054 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
3055 * @ioa_cfg: ioa config struct
3056 * @dump: dump struct
3061 static void ipr_get_ioa_dump(struct ipr_ioa_cfg
*ioa_cfg
, struct ipr_dump
*dump
)
3063 unsigned long start_addr
, sdt_word
;
3064 unsigned long lock_flags
= 0;
3065 struct ipr_driver_dump
*driver_dump
= &dump
->driver_dump
;
3066 struct ipr_ioa_dump
*ioa_dump
= &dump
->ioa_dump
;
3067 u32 num_entries
, max_num_entries
, start_off
, end_off
;
3068 u32 max_dump_size
, bytes_to_copy
, bytes_copied
, rc
;
3069 struct ipr_sdt
*sdt
;
3075 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3077 if (ioa_cfg
->sdt_state
!= READ_DUMP
) {
3078 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3082 if (ioa_cfg
->sis64
) {
3083 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3084 ssleep(IPR_DUMP_DELAY_SECONDS
);
3085 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3088 start_addr
= readl(ioa_cfg
->ioa_mailbox
);
3090 if (!ioa_cfg
->sis64
&& !ipr_sdt_is_fmt2(start_addr
)) {
3091 dev_err(&ioa_cfg
->pdev
->dev
,
3092 "Invalid dump table format: %lx\n", start_addr
);
3093 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3097 dev_err(&ioa_cfg
->pdev
->dev
, "Dump of IOA initiated\n");
3099 driver_dump
->hdr
.eye_catcher
= IPR_DUMP_EYE_CATCHER
;
3101 /* Initialize the overall dump header */
3102 driver_dump
->hdr
.len
= sizeof(struct ipr_driver_dump
);
3103 driver_dump
->hdr
.num_entries
= 1;
3104 driver_dump
->hdr
.first_entry_offset
= sizeof(struct ipr_dump_header
);
3105 driver_dump
->hdr
.status
= IPR_DUMP_STATUS_SUCCESS
;
3106 driver_dump
->hdr
.os
= IPR_DUMP_OS_LINUX
;
3107 driver_dump
->hdr
.driver_name
= IPR_DUMP_DRIVER_NAME
;
3109 ipr_dump_version_data(ioa_cfg
, driver_dump
);
3110 ipr_dump_location_data(ioa_cfg
, driver_dump
);
3111 ipr_dump_ioa_type_data(ioa_cfg
, driver_dump
);
3112 ipr_dump_trace_data(ioa_cfg
, driver_dump
);
3114 /* Update dump_header */
3115 driver_dump
->hdr
.len
+= sizeof(struct ipr_dump_entry_header
);
3117 /* IOA Dump entry */
3118 ipr_init_dump_entry_hdr(&ioa_dump
->hdr
);
3119 ioa_dump
->hdr
.len
= 0;
3120 ioa_dump
->hdr
.data_type
= IPR_DUMP_DATA_TYPE_BINARY
;
3121 ioa_dump
->hdr
.id
= IPR_DUMP_IOA_DUMP_ID
;
3123 /* First entries in sdt are actually a list of dump addresses and
3124 lengths to gather the real dump data. sdt represents the pointer
3125 to the ioa generated dump table. Dump data will be extracted based
3126 on entries in this table */
3127 sdt
= &ioa_dump
->sdt
;
3129 if (ioa_cfg
->sis64
) {
3130 max_num_entries
= IPR_FMT3_NUM_SDT_ENTRIES
;
3131 max_dump_size
= IPR_FMT3_MAX_IOA_DUMP_SIZE
;
3133 max_num_entries
= IPR_FMT2_NUM_SDT_ENTRIES
;
3134 max_dump_size
= IPR_FMT2_MAX_IOA_DUMP_SIZE
;
3137 bytes_to_copy
= offsetof(struct ipr_sdt
, entry
) +
3138 (max_num_entries
* sizeof(struct ipr_sdt_entry
));
3139 rc
= ipr_get_ldump_data_section(ioa_cfg
, start_addr
, (__be32
*)sdt
,
3140 bytes_to_copy
/ sizeof(__be32
));
3142 /* Smart Dump table is ready to use and the first entry is valid */
3143 if (rc
|| ((be32_to_cpu(sdt
->hdr
.state
) != IPR_FMT3_SDT_READY_TO_USE
) &&
3144 (be32_to_cpu(sdt
->hdr
.state
) != IPR_FMT2_SDT_READY_TO_USE
))) {
3145 dev_err(&ioa_cfg
->pdev
->dev
,
3146 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
3147 rc
, be32_to_cpu(sdt
->hdr
.state
));
3148 driver_dump
->hdr
.status
= IPR_DUMP_STATUS_FAILED
;
3149 ioa_cfg
->sdt_state
= DUMP_OBTAINED
;
3150 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3154 num_entries
= be32_to_cpu(sdt
->hdr
.num_entries_used
);
3156 if (num_entries
> max_num_entries
)
3157 num_entries
= max_num_entries
;
3159 /* Update dump length to the actual data to be copied */
3160 dump
->driver_dump
.hdr
.len
+= sizeof(struct ipr_sdt_header
);
3162 dump
->driver_dump
.hdr
.len
+= num_entries
* sizeof(struct ipr_sdt_entry
);
3164 dump
->driver_dump
.hdr
.len
+= max_num_entries
* sizeof(struct ipr_sdt_entry
);
3166 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3168 for (i
= 0; i
< num_entries
; i
++) {
3169 if (ioa_dump
->hdr
.len
> max_dump_size
) {
3170 driver_dump
->hdr
.status
= IPR_DUMP_STATUS_QUAL_SUCCESS
;
3174 if (sdt
->entry
[i
].flags
& IPR_SDT_VALID_ENTRY
) {
3175 sdt_word
= be32_to_cpu(sdt
->entry
[i
].start_token
);
3177 bytes_to_copy
= be32_to_cpu(sdt
->entry
[i
].end_token
);
3179 start_off
= sdt_word
& IPR_FMT2_MBX_ADDR_MASK
;
3180 end_off
= be32_to_cpu(sdt
->entry
[i
].end_token
);
3182 if (ipr_sdt_is_fmt2(sdt_word
) && sdt_word
)
3183 bytes_to_copy
= end_off
- start_off
;
3188 if (bytes_to_copy
> max_dump_size
) {
3189 sdt
->entry
[i
].flags
&= ~IPR_SDT_VALID_ENTRY
;
3193 /* Copy data from adapter to driver buffers */
3194 bytes_copied
= ipr_sdt_copy(ioa_cfg
, sdt_word
,
3197 ioa_dump
->hdr
.len
+= bytes_copied
;
3199 if (bytes_copied
!= bytes_to_copy
) {
3200 driver_dump
->hdr
.status
= IPR_DUMP_STATUS_QUAL_SUCCESS
;
3207 dev_err(&ioa_cfg
->pdev
->dev
, "Dump of IOA completed.\n");
3209 /* Update dump_header */
3210 driver_dump
->hdr
.len
+= ioa_dump
->hdr
.len
;
3212 ioa_cfg
->sdt_state
= DUMP_OBTAINED
;
3217 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3221 * ipr_release_dump - Free adapter dump memory
3222 * @kref: kref struct
3227 static void ipr_release_dump(struct kref
*kref
)
3229 struct ipr_dump
*dump
= container_of(kref
, struct ipr_dump
, kref
);
3230 struct ipr_ioa_cfg
*ioa_cfg
= dump
->ioa_cfg
;
3231 unsigned long lock_flags
= 0;
3235 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3236 ioa_cfg
->dump
= NULL
;
3237 ioa_cfg
->sdt_state
= INACTIVE
;
3238 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3240 for (i
= 0; i
< dump
->ioa_dump
.next_page_index
; i
++)
3241 free_page((unsigned long) dump
->ioa_dump
.ioa_data
[i
]);
3243 vfree(dump
->ioa_dump
.ioa_data
);
3249 * ipr_worker_thread - Worker thread
3250 * @work: ioa config struct
3252 * Called at task level from a work thread. This function takes care
3253 * of adding and removing device from the mid-layer as configuration
3254 * changes are detected by the adapter.
3259 static void ipr_worker_thread(struct work_struct
*work
)
3261 unsigned long lock_flags
;
3262 struct ipr_resource_entry
*res
;
3263 struct scsi_device
*sdev
;
3264 struct ipr_dump
*dump
;
3265 struct ipr_ioa_cfg
*ioa_cfg
=
3266 container_of(work
, struct ipr_ioa_cfg
, work_q
);
3267 u8 bus
, target
, lun
;
3271 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3273 if (ioa_cfg
->sdt_state
== READ_DUMP
) {
3274 dump
= ioa_cfg
->dump
;
3276 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3279 kref_get(&dump
->kref
);
3280 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3281 ipr_get_ioa_dump(ioa_cfg
, dump
);
3282 kref_put(&dump
->kref
, ipr_release_dump
);
3284 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3285 if (ioa_cfg
->sdt_state
== DUMP_OBTAINED
&& !ioa_cfg
->dump_timeout
)
3286 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
3287 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3294 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
) {
3295 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3299 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
3300 if (res
->del_from_ml
&& res
->sdev
) {
3303 if (!scsi_device_get(sdev
)) {
3304 if (!res
->add_to_ml
)
3305 list_move_tail(&res
->queue
, &ioa_cfg
->free_res_q
);
3307 res
->del_from_ml
= 0;
3308 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3309 scsi_remove_device(sdev
);
3310 scsi_device_put(sdev
);
3311 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3318 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
3319 if (res
->add_to_ml
) {
3321 target
= res
->target
;
3324 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3325 scsi_add_device(ioa_cfg
->host
, bus
, target
, lun
);
3326 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3331 ioa_cfg
->scan_done
= 1;
3332 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3333 kobject_uevent(&ioa_cfg
->host
->shost_dev
.kobj
, KOBJ_CHANGE
);
3337 #ifdef CONFIG_SCSI_IPR_TRACE
3339 * ipr_read_trace - Dump the adapter trace
3340 * @filp: open sysfs file
3341 * @kobj: kobject struct
3342 * @bin_attr: bin_attribute struct
3345 * @count: buffer size
3348 * number of bytes printed to buffer
3350 static ssize_t
ipr_read_trace(struct file
*filp
, struct kobject
*kobj
,
3351 struct bin_attribute
*bin_attr
,
3352 char *buf
, loff_t off
, size_t count
)
3354 struct device
*dev
= container_of(kobj
, struct device
, kobj
);
3355 struct Scsi_Host
*shost
= class_to_shost(dev
);
3356 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3357 unsigned long lock_flags
= 0;
3360 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3361 ret
= memory_read_from_buffer(buf
, count
, &off
, ioa_cfg
->trace
,
3363 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3368 static struct bin_attribute ipr_trace_attr
= {
3374 .read
= ipr_read_trace
,
3379 * ipr_show_fw_version - Show the firmware version
3380 * @dev: class device struct
3384 * number of bytes printed to buffer
3386 static ssize_t
ipr_show_fw_version(struct device
*dev
,
3387 struct device_attribute
*attr
, char *buf
)
3389 struct Scsi_Host
*shost
= class_to_shost(dev
);
3390 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3391 struct ipr_inquiry_page3
*ucode_vpd
= &ioa_cfg
->vpd_cbs
->page3_data
;
3392 unsigned long lock_flags
= 0;
3395 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3396 len
= snprintf(buf
, PAGE_SIZE
, "%02X%02X%02X%02X\n",
3397 ucode_vpd
->major_release
, ucode_vpd
->card_type
,
3398 ucode_vpd
->minor_release
[0],
3399 ucode_vpd
->minor_release
[1]);
3400 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3404 static struct device_attribute ipr_fw_version_attr
= {
3406 .name
= "fw_version",
3409 .show
= ipr_show_fw_version
,
3413 * ipr_show_log_level - Show the adapter's error logging level
3414 * @dev: class device struct
3418 * number of bytes printed to buffer
3420 static ssize_t
ipr_show_log_level(struct device
*dev
,
3421 struct device_attribute
*attr
, char *buf
)
3423 struct Scsi_Host
*shost
= class_to_shost(dev
);
3424 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3425 unsigned long lock_flags
= 0;
3428 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3429 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->log_level
);
3430 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3435 * ipr_store_log_level - Change the adapter's error logging level
3436 * @dev: class device struct
3440 * number of bytes printed to buffer
3442 static ssize_t
ipr_store_log_level(struct device
*dev
,
3443 struct device_attribute
*attr
,
3444 const char *buf
, size_t count
)
3446 struct Scsi_Host
*shost
= class_to_shost(dev
);
3447 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3448 unsigned long lock_flags
= 0;
3450 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3451 ioa_cfg
->log_level
= simple_strtoul(buf
, NULL
, 10);
3452 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3456 static struct device_attribute ipr_log_level_attr
= {
3458 .name
= "log_level",
3459 .mode
= S_IRUGO
| S_IWUSR
,
3461 .show
= ipr_show_log_level
,
3462 .store
= ipr_store_log_level
3466 * ipr_store_diagnostics - IOA Diagnostics interface
3467 * @dev: device struct
3469 * @count: buffer size
3471 * This function will reset the adapter and wait a reasonable
3472 * amount of time for any errors that the adapter might log.
3475 * count on success / other on failure
3477 static ssize_t
ipr_store_diagnostics(struct device
*dev
,
3478 struct device_attribute
*attr
,
3479 const char *buf
, size_t count
)
3481 struct Scsi_Host
*shost
= class_to_shost(dev
);
3482 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3483 unsigned long lock_flags
= 0;
3486 if (!capable(CAP_SYS_ADMIN
))
3489 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3490 while (ioa_cfg
->in_reset_reload
) {
3491 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3492 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3493 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3496 ioa_cfg
->errors_logged
= 0;
3497 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
3499 if (ioa_cfg
->in_reset_reload
) {
3500 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3501 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3503 /* Wait for a second for any errors to be logged */
3506 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3510 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3511 if (ioa_cfg
->in_reset_reload
|| ioa_cfg
->errors_logged
)
3513 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3518 static struct device_attribute ipr_diagnostics_attr
= {
3520 .name
= "run_diagnostics",
3523 .store
= ipr_store_diagnostics
3527 * ipr_show_adapter_state - Show the adapter's state
3528 * @class_dev: device struct
3532 * number of bytes printed to buffer
3534 static ssize_t
ipr_show_adapter_state(struct device
*dev
,
3535 struct device_attribute
*attr
, char *buf
)
3537 struct Scsi_Host
*shost
= class_to_shost(dev
);
3538 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3539 unsigned long lock_flags
= 0;
3542 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3543 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
3544 len
= snprintf(buf
, PAGE_SIZE
, "offline\n");
3546 len
= snprintf(buf
, PAGE_SIZE
, "online\n");
3547 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3552 * ipr_store_adapter_state - Change adapter state
3553 * @dev: device struct
3555 * @count: buffer size
3557 * This function will change the adapter's state.
3560 * count on success / other on failure
3562 static ssize_t
ipr_store_adapter_state(struct device
*dev
,
3563 struct device_attribute
*attr
,
3564 const char *buf
, size_t count
)
3566 struct Scsi_Host
*shost
= class_to_shost(dev
);
3567 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3568 unsigned long lock_flags
;
3569 int result
= count
, i
;
3571 if (!capable(CAP_SYS_ADMIN
))
3574 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3575 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
&&
3576 !strncmp(buf
, "online", 6)) {
3577 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
3578 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
3579 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 0;
3580 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
3583 ioa_cfg
->reset_retries
= 0;
3584 ioa_cfg
->in_ioa_bringdown
= 0;
3585 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
3587 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3588 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3593 static struct device_attribute ipr_ioa_state_attr
= {
3595 .name
= "online_state",
3596 .mode
= S_IRUGO
| S_IWUSR
,
3598 .show
= ipr_show_adapter_state
,
3599 .store
= ipr_store_adapter_state
3603 * ipr_store_reset_adapter - Reset the adapter
3604 * @dev: device struct
3606 * @count: buffer size
3608 * This function will reset the adapter.
3611 * count on success / other on failure
3613 static ssize_t
ipr_store_reset_adapter(struct device
*dev
,
3614 struct device_attribute
*attr
,
3615 const char *buf
, size_t count
)
3617 struct Scsi_Host
*shost
= class_to_shost(dev
);
3618 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3619 unsigned long lock_flags
;
3622 if (!capable(CAP_SYS_ADMIN
))
3625 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3626 if (!ioa_cfg
->in_reset_reload
)
3627 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
3628 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3629 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3634 static struct device_attribute ipr_ioa_reset_attr
= {
3636 .name
= "reset_host",
3639 .store
= ipr_store_reset_adapter
3642 static int ipr_iopoll(struct irq_poll
*iop
, int budget
);
3644 * ipr_show_iopoll_weight - Show ipr polling mode
3645 * @dev: class device struct
3649 * number of bytes printed to buffer
3651 static ssize_t
ipr_show_iopoll_weight(struct device
*dev
,
3652 struct device_attribute
*attr
, char *buf
)
3654 struct Scsi_Host
*shost
= class_to_shost(dev
);
3655 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3656 unsigned long lock_flags
= 0;
3659 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
3660 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->iopoll_weight
);
3661 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
3667 * ipr_store_iopoll_weight - Change the adapter's polling mode
3668 * @dev: class device struct
3672 * number of bytes printed to buffer
3674 static ssize_t
ipr_store_iopoll_weight(struct device
*dev
,
3675 struct device_attribute
*attr
,
3676 const char *buf
, size_t count
)
3678 struct Scsi_Host
*shost
= class_to_shost(dev
);
3679 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
3680 unsigned long user_iopoll_weight
;
3681 unsigned long lock_flags
= 0;
3684 if (!ioa_cfg
->sis64
) {
3685 dev_info(&ioa_cfg
->pdev
->dev
, "irq_poll not supported on this adapter\n");
3688 if (kstrtoul(buf
, 10, &user_iopoll_weight
))
3691 if (user_iopoll_weight
> 256) {
3692 dev_info(&ioa_cfg
->pdev
->dev
, "Invalid irq_poll weight. It must be less than 256\n");
3696 if (user_iopoll_weight
== ioa_cfg
->iopoll_weight
) {
3697 dev_info(&ioa_cfg
->pdev
->dev
, "Current irq_poll weight has the same weight\n");
3701 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
3702 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++)
3703 irq_poll_disable(&ioa_cfg
->hrrq
[i
].iopoll
);
3706 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
3707 ioa_cfg
->iopoll_weight
= user_iopoll_weight
;
3708 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
3709 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++) {
3710 irq_poll_init(&ioa_cfg
->hrrq
[i
].iopoll
,
3711 ioa_cfg
->iopoll_weight
, ipr_iopoll
);
3714 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
3719 static struct device_attribute ipr_iopoll_weight_attr
= {
3721 .name
= "iopoll_weight",
3722 .mode
= S_IRUGO
| S_IWUSR
,
3724 .show
= ipr_show_iopoll_weight
,
3725 .store
= ipr_store_iopoll_weight
3729 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3730 * @buf_len: buffer length
3732 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3733 * list to use for microcode download
3736 * pointer to sglist / NULL on failure
3738 static struct ipr_sglist
*ipr_alloc_ucode_buffer(int buf_len
)
3740 int sg_size
, order
, bsize_elem
, num_elem
, i
, j
;
3741 struct ipr_sglist
*sglist
;
3742 struct scatterlist
*scatterlist
;
3745 /* Get the minimum size per scatter/gather element */
3746 sg_size
= buf_len
/ (IPR_MAX_SGLIST
- 1);
3748 /* Get the actual size per element */
3749 order
= get_order(sg_size
);
3751 /* Determine the actual number of bytes per element */
3752 bsize_elem
= PAGE_SIZE
* (1 << order
);
3754 /* Determine the actual number of sg entries needed */
3755 if (buf_len
% bsize_elem
)
3756 num_elem
= (buf_len
/ bsize_elem
) + 1;
3758 num_elem
= buf_len
/ bsize_elem
;
3760 /* Allocate a scatter/gather list for the DMA */
3761 sglist
= kzalloc(sizeof(struct ipr_sglist
) +
3762 (sizeof(struct scatterlist
) * (num_elem
- 1)),
3765 if (sglist
== NULL
) {
3770 scatterlist
= sglist
->scatterlist
;
3771 sg_init_table(scatterlist
, num_elem
);
3773 sglist
->order
= order
;
3774 sglist
->num_sg
= num_elem
;
3776 /* Allocate a bunch of sg elements */
3777 for (i
= 0; i
< num_elem
; i
++) {
3778 page
= alloc_pages(GFP_KERNEL
, order
);
3782 /* Free up what we already allocated */
3783 for (j
= i
- 1; j
>= 0; j
--)
3784 __free_pages(sg_page(&scatterlist
[j
]), order
);
3789 sg_set_page(&scatterlist
[i
], page
, 0, 0);
3796 * ipr_free_ucode_buffer - Frees a microcode download buffer
3797 * @p_dnld: scatter/gather list pointer
3799 * Free a DMA'able ucode download buffer previously allocated with
3800 * ipr_alloc_ucode_buffer
3805 static void ipr_free_ucode_buffer(struct ipr_sglist
*sglist
)
3809 for (i
= 0; i
< sglist
->num_sg
; i
++)
3810 __free_pages(sg_page(&sglist
->scatterlist
[i
]), sglist
->order
);
3816 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3817 * @sglist: scatter/gather list pointer
3818 * @buffer: buffer pointer
3819 * @len: buffer length
3821 * Copy a microcode image from a user buffer into a buffer allocated by
3822 * ipr_alloc_ucode_buffer
3825 * 0 on success / other on failure
3827 static int ipr_copy_ucode_buffer(struct ipr_sglist
*sglist
,
3828 u8
*buffer
, u32 len
)
3830 int bsize_elem
, i
, result
= 0;
3831 struct scatterlist
*scatterlist
;
3834 /* Determine the actual number of bytes per element */
3835 bsize_elem
= PAGE_SIZE
* (1 << sglist
->order
);
3837 scatterlist
= sglist
->scatterlist
;
3839 for (i
= 0; i
< (len
/ bsize_elem
); i
++, buffer
+= bsize_elem
) {
3840 struct page
*page
= sg_page(&scatterlist
[i
]);
3843 memcpy(kaddr
, buffer
, bsize_elem
);
3846 scatterlist
[i
].length
= bsize_elem
;
3854 if (len
% bsize_elem
) {
3855 struct page
*page
= sg_page(&scatterlist
[i
]);
3858 memcpy(kaddr
, buffer
, len
% bsize_elem
);
3861 scatterlist
[i
].length
= len
% bsize_elem
;
3864 sglist
->buffer_len
= len
;
3869 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3870 * @ipr_cmd: ipr command struct
3871 * @sglist: scatter/gather list
3873 * Builds a microcode download IOA data list (IOADL).
3876 static void ipr_build_ucode_ioadl64(struct ipr_cmnd
*ipr_cmd
,
3877 struct ipr_sglist
*sglist
)
3879 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
3880 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ioadl64
;
3881 struct scatterlist
*scatterlist
= sglist
->scatterlist
;
3884 ipr_cmd
->dma_use_sg
= sglist
->num_dma_sg
;
3885 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
3886 ioarcb
->data_transfer_length
= cpu_to_be32(sglist
->buffer_len
);
3889 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
3890 for (i
= 0; i
< ipr_cmd
->dma_use_sg
; i
++) {
3891 ioadl64
[i
].flags
= cpu_to_be32(IPR_IOADL_FLAGS_WRITE
);
3892 ioadl64
[i
].data_len
= cpu_to_be32(sg_dma_len(&scatterlist
[i
]));
3893 ioadl64
[i
].address
= cpu_to_be64(sg_dma_address(&scatterlist
[i
]));
3896 ioadl64
[i
-1].flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
3900 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3901 * @ipr_cmd: ipr command struct
3902 * @sglist: scatter/gather list
3904 * Builds a microcode download IOA data list (IOADL).
3907 static void ipr_build_ucode_ioadl(struct ipr_cmnd
*ipr_cmd
,
3908 struct ipr_sglist
*sglist
)
3910 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
3911 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
3912 struct scatterlist
*scatterlist
= sglist
->scatterlist
;
3915 ipr_cmd
->dma_use_sg
= sglist
->num_dma_sg
;
3916 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
3917 ioarcb
->data_transfer_length
= cpu_to_be32(sglist
->buffer_len
);
3920 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
3922 for (i
= 0; i
< ipr_cmd
->dma_use_sg
; i
++) {
3923 ioadl
[i
].flags_and_data_len
=
3924 cpu_to_be32(IPR_IOADL_FLAGS_WRITE
| sg_dma_len(&scatterlist
[i
]));
3926 cpu_to_be32(sg_dma_address(&scatterlist
[i
]));
3929 ioadl
[i
-1].flags_and_data_len
|=
3930 cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
3934 * ipr_update_ioa_ucode - Update IOA's microcode
3935 * @ioa_cfg: ioa config struct
3936 * @sglist: scatter/gather list
3938 * Initiate an adapter reset to update the IOA's microcode
3941 * 0 on success / -EIO on failure
3943 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg
*ioa_cfg
,
3944 struct ipr_sglist
*sglist
)
3946 unsigned long lock_flags
;
3948 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3949 while (ioa_cfg
->in_reset_reload
) {
3950 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3951 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3952 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3955 if (ioa_cfg
->ucode_sglist
) {
3956 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3957 dev_err(&ioa_cfg
->pdev
->dev
,
3958 "Microcode download already in progress\n");
3962 sglist
->num_dma_sg
= dma_map_sg(&ioa_cfg
->pdev
->dev
,
3963 sglist
->scatterlist
, sglist
->num_sg
,
3966 if (!sglist
->num_dma_sg
) {
3967 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3968 dev_err(&ioa_cfg
->pdev
->dev
,
3969 "Failed to map microcode download buffer!\n");
3973 ioa_cfg
->ucode_sglist
= sglist
;
3974 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
3975 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3976 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
3978 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
3979 ioa_cfg
->ucode_sglist
= NULL
;
3980 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
3985 * ipr_store_update_fw - Update the firmware on the adapter
3986 * @class_dev: device struct
3988 * @count: buffer size
3990 * This function will update the firmware on the adapter.
3993 * count on success / other on failure
3995 static ssize_t
ipr_store_update_fw(struct device
*dev
,
3996 struct device_attribute
*attr
,
3997 const char *buf
, size_t count
)
3999 struct Scsi_Host
*shost
= class_to_shost(dev
);
4000 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4001 struct ipr_ucode_image_header
*image_hdr
;
4002 const struct firmware
*fw_entry
;
4003 struct ipr_sglist
*sglist
;
4007 int result
, dnld_size
;
4009 if (!capable(CAP_SYS_ADMIN
))
4012 snprintf(fname
, sizeof(fname
), "%s", buf
);
4014 endline
= strchr(fname
, '\n');
4018 if (request_firmware(&fw_entry
, fname
, &ioa_cfg
->pdev
->dev
)) {
4019 dev_err(&ioa_cfg
->pdev
->dev
, "Firmware file %s not found\n", fname
);
4023 image_hdr
= (struct ipr_ucode_image_header
*)fw_entry
->data
;
4025 src
= (u8
*)image_hdr
+ be32_to_cpu(image_hdr
->header_length
);
4026 dnld_size
= fw_entry
->size
- be32_to_cpu(image_hdr
->header_length
);
4027 sglist
= ipr_alloc_ucode_buffer(dnld_size
);
4030 dev_err(&ioa_cfg
->pdev
->dev
, "Microcode buffer allocation failed\n");
4031 release_firmware(fw_entry
);
4035 result
= ipr_copy_ucode_buffer(sglist
, src
, dnld_size
);
4038 dev_err(&ioa_cfg
->pdev
->dev
,
4039 "Microcode buffer copy to DMA buffer failed\n");
4043 ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n");
4045 result
= ipr_update_ioa_ucode(ioa_cfg
, sglist
);
4050 ipr_free_ucode_buffer(sglist
);
4051 release_firmware(fw_entry
);
4055 static struct device_attribute ipr_update_fw_attr
= {
4057 .name
= "update_fw",
4060 .store
= ipr_store_update_fw
4064 * ipr_show_fw_type - Show the adapter's firmware type.
4065 * @dev: class device struct
4069 * number of bytes printed to buffer
4071 static ssize_t
ipr_show_fw_type(struct device
*dev
,
4072 struct device_attribute
*attr
, char *buf
)
4074 struct Scsi_Host
*shost
= class_to_shost(dev
);
4075 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4076 unsigned long lock_flags
= 0;
4079 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4080 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", ioa_cfg
->sis64
);
4081 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4085 static struct device_attribute ipr_ioa_fw_type_attr
= {
4090 .show
= ipr_show_fw_type
4093 static struct device_attribute
*ipr_ioa_attrs
[] = {
4094 &ipr_fw_version_attr
,
4095 &ipr_log_level_attr
,
4096 &ipr_diagnostics_attr
,
4097 &ipr_ioa_state_attr
,
4098 &ipr_ioa_reset_attr
,
4099 &ipr_update_fw_attr
,
4100 &ipr_ioa_fw_type_attr
,
4101 &ipr_iopoll_weight_attr
,
4105 #ifdef CONFIG_SCSI_IPR_DUMP
4107 * ipr_read_dump - Dump the adapter
4108 * @filp: open sysfs file
4109 * @kobj: kobject struct
4110 * @bin_attr: bin_attribute struct
4113 * @count: buffer size
4116 * number of bytes printed to buffer
4118 static ssize_t
ipr_read_dump(struct file
*filp
, struct kobject
*kobj
,
4119 struct bin_attribute
*bin_attr
,
4120 char *buf
, loff_t off
, size_t count
)
4122 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4123 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4124 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4125 struct ipr_dump
*dump
;
4126 unsigned long lock_flags
= 0;
4131 if (!capable(CAP_SYS_ADMIN
))
4134 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4135 dump
= ioa_cfg
->dump
;
4137 if (ioa_cfg
->sdt_state
!= DUMP_OBTAINED
|| !dump
) {
4138 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4141 kref_get(&dump
->kref
);
4142 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4144 if (off
> dump
->driver_dump
.hdr
.len
) {
4145 kref_put(&dump
->kref
, ipr_release_dump
);
4149 if (off
+ count
> dump
->driver_dump
.hdr
.len
) {
4150 count
= dump
->driver_dump
.hdr
.len
- off
;
4154 if (count
&& off
< sizeof(dump
->driver_dump
)) {
4155 if (off
+ count
> sizeof(dump
->driver_dump
))
4156 len
= sizeof(dump
->driver_dump
) - off
;
4159 src
= (u8
*)&dump
->driver_dump
+ off
;
4160 memcpy(buf
, src
, len
);
4166 off
-= sizeof(dump
->driver_dump
);
4169 sdt_end
= offsetof(struct ipr_ioa_dump
, sdt
.entry
) +
4170 (be32_to_cpu(dump
->ioa_dump
.sdt
.hdr
.num_entries_used
) *
4171 sizeof(struct ipr_sdt_entry
));
4173 sdt_end
= offsetof(struct ipr_ioa_dump
, sdt
.entry
) +
4174 (IPR_FMT2_NUM_SDT_ENTRIES
* sizeof(struct ipr_sdt_entry
));
4176 if (count
&& off
< sdt_end
) {
4177 if (off
+ count
> sdt_end
)
4178 len
= sdt_end
- off
;
4181 src
= (u8
*)&dump
->ioa_dump
+ off
;
4182 memcpy(buf
, src
, len
);
4191 if ((off
& PAGE_MASK
) != ((off
+ count
) & PAGE_MASK
))
4192 len
= PAGE_ALIGN(off
) - off
;
4195 src
= (u8
*)dump
->ioa_dump
.ioa_data
[(off
& PAGE_MASK
) >> PAGE_SHIFT
];
4196 src
+= off
& ~PAGE_MASK
;
4197 memcpy(buf
, src
, len
);
4203 kref_put(&dump
->kref
, ipr_release_dump
);
4208 * ipr_alloc_dump - Prepare for adapter dump
4209 * @ioa_cfg: ioa config struct
4212 * 0 on success / other on failure
4214 static int ipr_alloc_dump(struct ipr_ioa_cfg
*ioa_cfg
)
4216 struct ipr_dump
*dump
;
4218 unsigned long lock_flags
= 0;
4220 dump
= kzalloc(sizeof(struct ipr_dump
), GFP_KERNEL
);
4223 ipr_err("Dump memory allocation failed\n");
4228 ioa_data
= vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES
* sizeof(__be32
*));
4230 ioa_data
= vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES
* sizeof(__be32
*));
4233 ipr_err("Dump memory allocation failed\n");
4238 dump
->ioa_dump
.ioa_data
= ioa_data
;
4240 kref_init(&dump
->kref
);
4241 dump
->ioa_cfg
= ioa_cfg
;
4243 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4245 if (INACTIVE
!= ioa_cfg
->sdt_state
) {
4246 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4247 vfree(dump
->ioa_dump
.ioa_data
);
4252 ioa_cfg
->dump
= dump
;
4253 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
4254 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
&& !ioa_cfg
->dump_taken
) {
4255 ioa_cfg
->dump_taken
= 1;
4256 schedule_work(&ioa_cfg
->work_q
);
4258 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4264 * ipr_free_dump - Free adapter dump memory
4265 * @ioa_cfg: ioa config struct
4268 * 0 on success / other on failure
4270 static int ipr_free_dump(struct ipr_ioa_cfg
*ioa_cfg
)
4272 struct ipr_dump
*dump
;
4273 unsigned long lock_flags
= 0;
4277 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4278 dump
= ioa_cfg
->dump
;
4280 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4284 ioa_cfg
->dump
= NULL
;
4285 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4287 kref_put(&dump
->kref
, ipr_release_dump
);
4294 * ipr_write_dump - Setup dump state of adapter
4295 * @filp: open sysfs file
4296 * @kobj: kobject struct
4297 * @bin_attr: bin_attribute struct
4300 * @count: buffer size
4303 * number of bytes printed to buffer
4305 static ssize_t
ipr_write_dump(struct file
*filp
, struct kobject
*kobj
,
4306 struct bin_attribute
*bin_attr
,
4307 char *buf
, loff_t off
, size_t count
)
4309 struct device
*cdev
= container_of(kobj
, struct device
, kobj
);
4310 struct Scsi_Host
*shost
= class_to_shost(cdev
);
4311 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
4314 if (!capable(CAP_SYS_ADMIN
))
4318 rc
= ipr_alloc_dump(ioa_cfg
);
4319 else if (buf
[0] == '0')
4320 rc
= ipr_free_dump(ioa_cfg
);
4330 static struct bin_attribute ipr_dump_attr
= {
4333 .mode
= S_IRUSR
| S_IWUSR
,
4336 .read
= ipr_read_dump
,
4337 .write
= ipr_write_dump
4340 static int ipr_free_dump(struct ipr_ioa_cfg
*ioa_cfg
) { return 0; };
4344 * ipr_change_queue_depth - Change the device's queue depth
4345 * @sdev: scsi device struct
4346 * @qdepth: depth to set
4347 * @reason: calling context
4352 static int ipr_change_queue_depth(struct scsi_device
*sdev
, int qdepth
)
4354 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4355 struct ipr_resource_entry
*res
;
4356 unsigned long lock_flags
= 0;
4358 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4359 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4361 if (res
&& ipr_is_gata(res
) && qdepth
> IPR_MAX_CMD_PER_ATA_LUN
)
4362 qdepth
= IPR_MAX_CMD_PER_ATA_LUN
;
4363 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4365 scsi_change_queue_depth(sdev
, qdepth
);
4366 return sdev
->queue_depth
;
4370 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4371 * @dev: device struct
4372 * @attr: device attribute structure
4376 * number of bytes printed to buffer
4378 static ssize_t
ipr_show_adapter_handle(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4380 struct scsi_device
*sdev
= to_scsi_device(dev
);
4381 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4382 struct ipr_resource_entry
*res
;
4383 unsigned long lock_flags
= 0;
4384 ssize_t len
= -ENXIO
;
4386 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4387 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4389 len
= snprintf(buf
, PAGE_SIZE
, "%08X\n", res
->res_handle
);
4390 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4394 static struct device_attribute ipr_adapter_handle_attr
= {
4396 .name
= "adapter_handle",
4399 .show
= ipr_show_adapter_handle
4403 * ipr_show_resource_path - Show the resource path or the resource address for
4405 * @dev: device struct
4406 * @attr: device attribute structure
4410 * number of bytes printed to buffer
4412 static ssize_t
ipr_show_resource_path(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4414 struct scsi_device
*sdev
= to_scsi_device(dev
);
4415 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4416 struct ipr_resource_entry
*res
;
4417 unsigned long lock_flags
= 0;
4418 ssize_t len
= -ENXIO
;
4419 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
4421 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4422 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4423 if (res
&& ioa_cfg
->sis64
)
4424 len
= snprintf(buf
, PAGE_SIZE
, "%s\n",
4425 __ipr_format_res_path(res
->res_path
, buffer
,
4428 len
= snprintf(buf
, PAGE_SIZE
, "%d:%d:%d:%d\n", ioa_cfg
->host
->host_no
,
4429 res
->bus
, res
->target
, res
->lun
);
4431 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4435 static struct device_attribute ipr_resource_path_attr
= {
4437 .name
= "resource_path",
4440 .show
= ipr_show_resource_path
4444 * ipr_show_device_id - Show the device_id for this device.
4445 * @dev: device struct
4446 * @attr: device attribute structure
4450 * number of bytes printed to buffer
4452 static ssize_t
ipr_show_device_id(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4454 struct scsi_device
*sdev
= to_scsi_device(dev
);
4455 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4456 struct ipr_resource_entry
*res
;
4457 unsigned long lock_flags
= 0;
4458 ssize_t len
= -ENXIO
;
4460 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4461 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4462 if (res
&& ioa_cfg
->sis64
)
4463 len
= snprintf(buf
, PAGE_SIZE
, "0x%llx\n", be64_to_cpu(res
->dev_id
));
4465 len
= snprintf(buf
, PAGE_SIZE
, "0x%llx\n", res
->lun_wwn
);
4467 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4471 static struct device_attribute ipr_device_id_attr
= {
4473 .name
= "device_id",
4476 .show
= ipr_show_device_id
4480 * ipr_show_resource_type - Show the resource type for this device.
4481 * @dev: device struct
4482 * @attr: device attribute structure
4486 * number of bytes printed to buffer
4488 static ssize_t
ipr_show_resource_type(struct device
*dev
, struct device_attribute
*attr
, char *buf
)
4490 struct scsi_device
*sdev
= to_scsi_device(dev
);
4491 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4492 struct ipr_resource_entry
*res
;
4493 unsigned long lock_flags
= 0;
4494 ssize_t len
= -ENXIO
;
4496 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4497 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4500 len
= snprintf(buf
, PAGE_SIZE
, "%x\n", res
->type
);
4502 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4506 static struct device_attribute ipr_resource_type_attr
= {
4508 .name
= "resource_type",
4511 .show
= ipr_show_resource_type
4515 * ipr_show_raw_mode - Show the adapter's raw mode
4516 * @dev: class device struct
4520 * number of bytes printed to buffer
4522 static ssize_t
ipr_show_raw_mode(struct device
*dev
,
4523 struct device_attribute
*attr
, char *buf
)
4525 struct scsi_device
*sdev
= to_scsi_device(dev
);
4526 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4527 struct ipr_resource_entry
*res
;
4528 unsigned long lock_flags
= 0;
4531 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4532 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4534 len
= snprintf(buf
, PAGE_SIZE
, "%d\n", res
->raw_mode
);
4537 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4542 * ipr_store_raw_mode - Change the adapter's raw mode
4543 * @dev: class device struct
4547 * number of bytes printed to buffer
4549 static ssize_t
ipr_store_raw_mode(struct device
*dev
,
4550 struct device_attribute
*attr
,
4551 const char *buf
, size_t count
)
4553 struct scsi_device
*sdev
= to_scsi_device(dev
);
4554 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)sdev
->host
->hostdata
;
4555 struct ipr_resource_entry
*res
;
4556 unsigned long lock_flags
= 0;
4559 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4560 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
4562 if (ipr_is_af_dasd_device(res
)) {
4563 res
->raw_mode
= simple_strtoul(buf
, NULL
, 10);
4566 sdev_printk(KERN_INFO
, res
->sdev
, "raw mode is %s\n",
4567 res
->raw_mode
? "enabled" : "disabled");
4572 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4576 static struct device_attribute ipr_raw_mode_attr
= {
4579 .mode
= S_IRUGO
| S_IWUSR
,
4581 .show
= ipr_show_raw_mode
,
4582 .store
= ipr_store_raw_mode
4585 static struct device_attribute
*ipr_dev_attrs
[] = {
4586 &ipr_adapter_handle_attr
,
4587 &ipr_resource_path_attr
,
4588 &ipr_device_id_attr
,
4589 &ipr_resource_type_attr
,
4595 * ipr_biosparam - Return the HSC mapping
4596 * @sdev: scsi device struct
4597 * @block_device: block device pointer
4598 * @capacity: capacity of the device
4599 * @parm: Array containing returned HSC values.
4601 * This function generates the HSC parms that fdisk uses.
4602 * We want to make sure we return something that places partitions
4603 * on 4k boundaries for best performance with the IOA.
4608 static int ipr_biosparam(struct scsi_device
*sdev
,
4609 struct block_device
*block_device
,
4610 sector_t capacity
, int *parm
)
4618 cylinders
= capacity
;
4619 sector_div(cylinders
, (128 * 32));
4624 parm
[2] = cylinders
;
4630 * ipr_find_starget - Find target based on bus/target.
4631 * @starget: scsi target struct
4634 * resource entry pointer if found / NULL if not found
4636 static struct ipr_resource_entry
*ipr_find_starget(struct scsi_target
*starget
)
4638 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4639 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4640 struct ipr_resource_entry
*res
;
4642 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
4643 if ((res
->bus
== starget
->channel
) &&
4644 (res
->target
== starget
->id
)) {
4652 static struct ata_port_info sata_port_info
;
4655 * ipr_target_alloc - Prepare for commands to a SCSI target
4656 * @starget: scsi target struct
4658 * If the device is a SATA device, this function allocates an
4659 * ATA port with libata, else it does nothing.
4662 * 0 on success / non-0 on failure
4664 static int ipr_target_alloc(struct scsi_target
*starget
)
4666 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4667 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4668 struct ipr_sata_port
*sata_port
;
4669 struct ata_port
*ap
;
4670 struct ipr_resource_entry
*res
;
4671 unsigned long lock_flags
;
4673 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4674 res
= ipr_find_starget(starget
);
4675 starget
->hostdata
= NULL
;
4677 if (res
&& ipr_is_gata(res
)) {
4678 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4679 sata_port
= kzalloc(sizeof(*sata_port
), GFP_KERNEL
);
4683 ap
= ata_sas_port_alloc(&ioa_cfg
->ata_host
, &sata_port_info
, shost
);
4685 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4686 sata_port
->ioa_cfg
= ioa_cfg
;
4688 sata_port
->res
= res
;
4690 res
->sata_port
= sata_port
;
4691 ap
->private_data
= sata_port
;
4692 starget
->hostdata
= sata_port
;
4698 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4704 * ipr_target_destroy - Destroy a SCSI target
4705 * @starget: scsi target struct
4707 * If the device was a SATA device, this function frees the libata
4708 * ATA port, else it does nothing.
4711 static void ipr_target_destroy(struct scsi_target
*starget
)
4713 struct ipr_sata_port
*sata_port
= starget
->hostdata
;
4714 struct Scsi_Host
*shost
= dev_to_shost(&starget
->dev
);
4715 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
4717 if (ioa_cfg
->sis64
) {
4718 if (!ipr_find_starget(starget
)) {
4719 if (starget
->channel
== IPR_ARRAY_VIRTUAL_BUS
)
4720 clear_bit(starget
->id
, ioa_cfg
->array_ids
);
4721 else if (starget
->channel
== IPR_VSET_VIRTUAL_BUS
)
4722 clear_bit(starget
->id
, ioa_cfg
->vset_ids
);
4723 else if (starget
->channel
== 0)
4724 clear_bit(starget
->id
, ioa_cfg
->target_ids
);
4729 starget
->hostdata
= NULL
;
4730 ata_sas_port_destroy(sata_port
->ap
);
4736 * ipr_find_sdev - Find device based on bus/target/lun.
4737 * @sdev: scsi device struct
4740 * resource entry pointer if found / NULL if not found
4742 static struct ipr_resource_entry
*ipr_find_sdev(struct scsi_device
*sdev
)
4744 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4745 struct ipr_resource_entry
*res
;
4747 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
4748 if ((res
->bus
== sdev
->channel
) &&
4749 (res
->target
== sdev
->id
) &&
4750 (res
->lun
== sdev
->lun
))
4758 * ipr_slave_destroy - Unconfigure a SCSI device
4759 * @sdev: scsi device struct
4764 static void ipr_slave_destroy(struct scsi_device
*sdev
)
4766 struct ipr_resource_entry
*res
;
4767 struct ipr_ioa_cfg
*ioa_cfg
;
4768 unsigned long lock_flags
= 0;
4770 ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4772 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4773 res
= (struct ipr_resource_entry
*) sdev
->hostdata
;
4776 res
->sata_port
->ap
->link
.device
[0].class = ATA_DEV_NONE
;
4777 sdev
->hostdata
= NULL
;
4779 res
->sata_port
= NULL
;
4781 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4785 * ipr_slave_configure - Configure a SCSI device
4786 * @sdev: scsi device struct
4788 * This function configures the specified scsi device.
4793 static int ipr_slave_configure(struct scsi_device
*sdev
)
4795 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4796 struct ipr_resource_entry
*res
;
4797 struct ata_port
*ap
= NULL
;
4798 unsigned long lock_flags
= 0;
4799 char buffer
[IPR_MAX_RES_PATH_LENGTH
];
4801 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4802 res
= sdev
->hostdata
;
4804 if (ipr_is_af_dasd_device(res
))
4805 sdev
->type
= TYPE_RAID
;
4806 if (ipr_is_af_dasd_device(res
) || ipr_is_ioa_resource(res
)) {
4807 sdev
->scsi_level
= 4;
4808 sdev
->no_uld_attach
= 1;
4810 if (ipr_is_vset_device(res
)) {
4811 sdev
->scsi_level
= SCSI_SPC_3
;
4812 blk_queue_rq_timeout(sdev
->request_queue
,
4813 IPR_VSET_RW_TIMEOUT
);
4814 blk_queue_max_hw_sectors(sdev
->request_queue
, IPR_VSET_MAX_SECTORS
);
4816 if (ipr_is_gata(res
) && res
->sata_port
)
4817 ap
= res
->sata_port
->ap
;
4818 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4821 scsi_change_queue_depth(sdev
, IPR_MAX_CMD_PER_ATA_LUN
);
4822 ata_sas_slave_configure(sdev
, ap
);
4826 sdev_printk(KERN_INFO
, sdev
, "Resource path: %s\n",
4827 ipr_format_res_path(ioa_cfg
,
4828 res
->res_path
, buffer
, sizeof(buffer
)));
4831 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4836 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4837 * @sdev: scsi device struct
4839 * This function initializes an ATA port so that future commands
4840 * sent through queuecommand will work.
4845 static int ipr_ata_slave_alloc(struct scsi_device
*sdev
)
4847 struct ipr_sata_port
*sata_port
= NULL
;
4851 if (sdev
->sdev_target
)
4852 sata_port
= sdev
->sdev_target
->hostdata
;
4854 rc
= ata_sas_port_init(sata_port
->ap
);
4856 rc
= ata_sas_sync_probe(sata_port
->ap
);
4860 ipr_slave_destroy(sdev
);
4867 * ipr_slave_alloc - Prepare for commands to a device.
4868 * @sdev: scsi device struct
4870 * This function saves a pointer to the resource entry
4871 * in the scsi device struct if the device exists. We
4872 * can then use this pointer in ipr_queuecommand when
4873 * handling new commands.
4876 * 0 on success / -ENXIO if device does not exist
4878 static int ipr_slave_alloc(struct scsi_device
*sdev
)
4880 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) sdev
->host
->hostdata
;
4881 struct ipr_resource_entry
*res
;
4882 unsigned long lock_flags
;
4885 sdev
->hostdata
= NULL
;
4887 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4889 res
= ipr_find_sdev(sdev
);
4894 sdev
->hostdata
= res
;
4895 if (!ipr_is_naca_model(res
))
4896 res
->needs_sync_complete
= 1;
4898 if (ipr_is_gata(res
)) {
4899 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4900 return ipr_ata_slave_alloc(sdev
);
4904 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
4910 * ipr_match_lun - Match function for specified LUN
4911 * @ipr_cmd: ipr command struct
4912 * @device: device to match (sdev)
4915 * 1 if command matches sdev / 0 if command does not match sdev
4917 static int ipr_match_lun(struct ipr_cmnd
*ipr_cmd
, void *device
)
4919 if (ipr_cmd
->scsi_cmd
&& ipr_cmd
->scsi_cmd
->device
== device
)
4925 * ipr_wait_for_ops - Wait for matching commands to complete
4926 * @ipr_cmd: ipr command struct
4927 * @device: device to match (sdev)
4928 * @match: match function to use
4933 static int ipr_wait_for_ops(struct ipr_ioa_cfg
*ioa_cfg
, void *device
,
4934 int (*match
)(struct ipr_cmnd
*, void *))
4936 struct ipr_cmnd
*ipr_cmd
;
4938 unsigned long flags
;
4939 struct ipr_hrr_queue
*hrrq
;
4940 signed long timeout
= IPR_ABORT_TASK_TIMEOUT
;
4941 DECLARE_COMPLETION_ONSTACK(comp
);
4947 for_each_hrrq(hrrq
, ioa_cfg
) {
4948 spin_lock_irqsave(hrrq
->lock
, flags
);
4949 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
4950 if (match(ipr_cmd
, device
)) {
4951 ipr_cmd
->eh_comp
= &comp
;
4955 spin_unlock_irqrestore(hrrq
->lock
, flags
);
4959 timeout
= wait_for_completion_timeout(&comp
, timeout
);
4964 for_each_hrrq(hrrq
, ioa_cfg
) {
4965 spin_lock_irqsave(hrrq
->lock
, flags
);
4966 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
4967 if (match(ipr_cmd
, device
)) {
4968 ipr_cmd
->eh_comp
= NULL
;
4972 spin_unlock_irqrestore(hrrq
->lock
, flags
);
4976 dev_err(&ioa_cfg
->pdev
->dev
, "Timed out waiting for aborted commands\n");
4978 return wait
? FAILED
: SUCCESS
;
4987 static int ipr_eh_host_reset(struct scsi_cmnd
*cmd
)
4989 struct ipr_ioa_cfg
*ioa_cfg
;
4990 unsigned long lock_flags
= 0;
4994 ioa_cfg
= (struct ipr_ioa_cfg
*) cmd
->device
->host
->hostdata
;
4995 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
4997 if (!ioa_cfg
->in_reset_reload
&& !ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
4998 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_ABBREV
);
4999 dev_err(&ioa_cfg
->pdev
->dev
,
5000 "Adapter being reset as a result of error recovery.\n");
5002 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5003 ioa_cfg
->sdt_state
= GET_DUMP
;
5006 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5007 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
5008 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5010 /* If we got hit with a host reset while we were already resetting
5011 the adapter for some reason, and the reset failed. */
5012 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
5017 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5023 * ipr_device_reset - Reset the device
5024 * @ioa_cfg: ioa config struct
5025 * @res: resource entry struct
5027 * This function issues a device reset to the affected device.
5028 * If the device is a SCSI device, a LUN reset will be sent
5029 * to the device first. If that does not work, a target reset
5030 * will be sent. If the device is a SATA device, a PHY reset will
5034 * 0 on success / non-zero on failure
5036 static int ipr_device_reset(struct ipr_ioa_cfg
*ioa_cfg
,
5037 struct ipr_resource_entry
*res
)
5039 struct ipr_cmnd
*ipr_cmd
;
5040 struct ipr_ioarcb
*ioarcb
;
5041 struct ipr_cmd_pkt
*cmd_pkt
;
5042 struct ipr_ioarcb_ata_regs
*regs
;
5046 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5047 ioarcb
= &ipr_cmd
->ioarcb
;
5048 cmd_pkt
= &ioarcb
->cmd_pkt
;
5050 if (ipr_cmd
->ioa_cfg
->sis64
) {
5051 regs
= &ipr_cmd
->i
.ata_ioadl
.regs
;
5052 ioarcb
->add_cmd_parms_offset
= cpu_to_be16(sizeof(*ioarcb
));
5054 regs
= &ioarcb
->u
.add_data
.u
.regs
;
5056 ioarcb
->res_handle
= res
->res_handle
;
5057 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5058 cmd_pkt
->cdb
[0] = IPR_RESET_DEVICE
;
5059 if (ipr_is_gata(res
)) {
5060 cmd_pkt
->cdb
[2] = IPR_ATA_PHY_RESET
;
5061 ioarcb
->add_cmd_parms_len
= cpu_to_be16(sizeof(regs
->flags
));
5062 regs
->flags
|= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION
;
5065 ipr_send_blocking_cmd(ipr_cmd
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
5066 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5067 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5068 if (ipr_is_gata(res
) && res
->sata_port
&& ioasc
!= IPR_IOASC_IOA_WAS_RESET
) {
5069 if (ipr_cmd
->ioa_cfg
->sis64
)
5070 memcpy(&res
->sata_port
->ioasa
, &ipr_cmd
->s
.ioasa64
.u
.gata
,
5071 sizeof(struct ipr_ioasa_gata
));
5073 memcpy(&res
->sata_port
->ioasa
, &ipr_cmd
->s
.ioasa
.u
.gata
,
5074 sizeof(struct ipr_ioasa_gata
));
5078 return IPR_IOASC_SENSE_KEY(ioasc
) ? -EIO
: 0;
5082 * ipr_sata_reset - Reset the SATA port
5083 * @link: SATA link to reset
5084 * @classes: class of the attached device
5086 * This function issues a SATA phy reset to the affected ATA link.
5089 * 0 on success / non-zero on failure
5091 static int ipr_sata_reset(struct ata_link
*link
, unsigned int *classes
,
5092 unsigned long deadline
)
5094 struct ipr_sata_port
*sata_port
= link
->ap
->private_data
;
5095 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
5096 struct ipr_resource_entry
*res
;
5097 unsigned long lock_flags
= 0;
5101 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5102 while (ioa_cfg
->in_reset_reload
) {
5103 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5104 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
5105 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5108 res
= sata_port
->res
;
5110 rc
= ipr_device_reset(ioa_cfg
, res
);
5111 *classes
= res
->ata_class
;
5114 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5120 * ipr_eh_dev_reset - Reset the device
5121 * @scsi_cmd: scsi command struct
5123 * This function issues a device reset to the affected device.
5124 * A LUN reset will be sent to the device first. If that does
5125 * not work, a target reset will be sent.
5130 static int __ipr_eh_dev_reset(struct scsi_cmnd
*scsi_cmd
)
5132 struct ipr_cmnd
*ipr_cmd
;
5133 struct ipr_ioa_cfg
*ioa_cfg
;
5134 struct ipr_resource_entry
*res
;
5135 struct ata_port
*ap
;
5137 struct ipr_hrr_queue
*hrrq
;
5140 ioa_cfg
= (struct ipr_ioa_cfg
*) scsi_cmd
->device
->host
->hostdata
;
5141 res
= scsi_cmd
->device
->hostdata
;
5147 * If we are currently going through reset/reload, return failed. This will force the
5148 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
5151 if (ioa_cfg
->in_reset_reload
)
5153 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
5156 for_each_hrrq(hrrq
, ioa_cfg
) {
5157 spin_lock(&hrrq
->_lock
);
5158 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
5159 if (ipr_cmd
->ioarcb
.res_handle
== res
->res_handle
) {
5160 if (ipr_cmd
->scsi_cmd
)
5161 ipr_cmd
->done
= ipr_scsi_eh_done
;
5163 ipr_cmd
->done
= ipr_sata_eh_done
;
5165 !(ipr_cmd
->qc
->flags
& ATA_QCFLAG_FAILED
)) {
5166 ipr_cmd
->qc
->err_mask
|= AC_ERR_TIMEOUT
;
5167 ipr_cmd
->qc
->flags
|= ATA_QCFLAG_FAILED
;
5171 spin_unlock(&hrrq
->_lock
);
5173 res
->resetting_device
= 1;
5174 scmd_printk(KERN_ERR
, scsi_cmd
, "Resetting device\n");
5176 if (ipr_is_gata(res
) && res
->sata_port
) {
5177 ap
= res
->sata_port
->ap
;
5178 spin_unlock_irq(scsi_cmd
->device
->host
->host_lock
);
5179 ata_std_error_handler(ap
);
5180 spin_lock_irq(scsi_cmd
->device
->host
->host_lock
);
5182 for_each_hrrq(hrrq
, ioa_cfg
) {
5183 spin_lock(&hrrq
->_lock
);
5184 list_for_each_entry(ipr_cmd
,
5185 &hrrq
->hrrq_pending_q
, queue
) {
5186 if (ipr_cmd
->ioarcb
.res_handle
==
5192 spin_unlock(&hrrq
->_lock
);
5195 rc
= ipr_device_reset(ioa_cfg
, res
);
5196 res
->resetting_device
= 0;
5197 res
->reset_occurred
= 1;
5200 return rc
? FAILED
: SUCCESS
;
5203 static int ipr_eh_dev_reset(struct scsi_cmnd
*cmd
)
5206 struct ipr_ioa_cfg
*ioa_cfg
;
5208 ioa_cfg
= (struct ipr_ioa_cfg
*) cmd
->device
->host
->hostdata
;
5210 spin_lock_irq(cmd
->device
->host
->host_lock
);
5211 rc
= __ipr_eh_dev_reset(cmd
);
5212 spin_unlock_irq(cmd
->device
->host
->host_lock
);
5215 rc
= ipr_wait_for_ops(ioa_cfg
, cmd
->device
, ipr_match_lun
);
5221 * ipr_bus_reset_done - Op done function for bus reset.
5222 * @ipr_cmd: ipr command struct
5224 * This function is the op done function for a bus reset
5229 static void ipr_bus_reset_done(struct ipr_cmnd
*ipr_cmd
)
5231 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
5232 struct ipr_resource_entry
*res
;
5235 if (!ioa_cfg
->sis64
)
5236 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
5237 if (res
->res_handle
== ipr_cmd
->ioarcb
.res_handle
) {
5238 scsi_report_bus_reset(ioa_cfg
->host
, res
->bus
);
5244 * If abort has not completed, indicate the reset has, else call the
5245 * abort's done function to wake the sleeping eh thread
5247 if (ipr_cmd
->sibling
->sibling
)
5248 ipr_cmd
->sibling
->sibling
= NULL
;
5250 ipr_cmd
->sibling
->done(ipr_cmd
->sibling
);
5252 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5257 * ipr_abort_timeout - An abort task has timed out
5258 * @ipr_cmd: ipr command struct
5260 * This function handles when an abort task times out. If this
5261 * happens we issue a bus reset since we have resources tied
5262 * up that must be freed before returning to the midlayer.
5267 static void ipr_abort_timeout(struct ipr_cmnd
*ipr_cmd
)
5269 struct ipr_cmnd
*reset_cmd
;
5270 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
5271 struct ipr_cmd_pkt
*cmd_pkt
;
5272 unsigned long lock_flags
= 0;
5275 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
5276 if (ipr_cmd
->completion
.done
|| ioa_cfg
->in_reset_reload
) {
5277 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5281 sdev_printk(KERN_ERR
, ipr_cmd
->u
.sdev
, "Abort timed out. Resetting bus.\n");
5282 reset_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5283 ipr_cmd
->sibling
= reset_cmd
;
5284 reset_cmd
->sibling
= ipr_cmd
;
5285 reset_cmd
->ioarcb
.res_handle
= ipr_cmd
->ioarcb
.res_handle
;
5286 cmd_pkt
= &reset_cmd
->ioarcb
.cmd_pkt
;
5287 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5288 cmd_pkt
->cdb
[0] = IPR_RESET_DEVICE
;
5289 cmd_pkt
->cdb
[2] = IPR_RESET_TYPE_SELECT
| IPR_BUS_RESET
;
5291 ipr_do_req(reset_cmd
, ipr_bus_reset_done
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
5292 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
5297 * ipr_cancel_op - Cancel specified op
5298 * @scsi_cmd: scsi command struct
5300 * This function cancels specified op.
5305 static int ipr_cancel_op(struct scsi_cmnd
*scsi_cmd
)
5307 struct ipr_cmnd
*ipr_cmd
;
5308 struct ipr_ioa_cfg
*ioa_cfg
;
5309 struct ipr_resource_entry
*res
;
5310 struct ipr_cmd_pkt
*cmd_pkt
;
5313 struct ipr_hrr_queue
*hrrq
;
5316 ioa_cfg
= (struct ipr_ioa_cfg
*)scsi_cmd
->device
->host
->hostdata
;
5317 res
= scsi_cmd
->device
->hostdata
;
5319 /* If we are currently going through reset/reload, return failed.
5320 * This will force the mid-layer to call ipr_eh_host_reset,
5321 * which will then go to sleep and wait for the reset to complete
5323 if (ioa_cfg
->in_reset_reload
||
5324 ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
5330 * If we are aborting a timed out op, chances are that the timeout was caused
5331 * by a still not detected EEH error. In such cases, reading a register will
5332 * trigger the EEH recovery infrastructure.
5334 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
5336 if (!ipr_is_gscsi(res
))
5339 for_each_hrrq(hrrq
, ioa_cfg
) {
5340 spin_lock(&hrrq
->_lock
);
5341 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
5342 if (ipr_cmd
->scsi_cmd
== scsi_cmd
) {
5343 ipr_cmd
->done
= ipr_scsi_eh_done
;
5348 spin_unlock(&hrrq
->_lock
);
5354 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
5355 ipr_cmd
->ioarcb
.res_handle
= res
->res_handle
;
5356 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
5357 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5358 cmd_pkt
->cdb
[0] = IPR_CANCEL_ALL_REQUESTS
;
5359 ipr_cmd
->u
.sdev
= scsi_cmd
->device
;
5361 scmd_printk(KERN_ERR
, scsi_cmd
, "Aborting command: %02X\n",
5363 ipr_send_blocking_cmd(ipr_cmd
, ipr_abort_timeout
, IPR_CANCEL_ALL_TIMEOUT
);
5364 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5367 * If the abort task timed out and we sent a bus reset, we will get
5368 * one the following responses to the abort
5370 if (ioasc
== IPR_IOASC_BUS_WAS_RESET
|| ioasc
== IPR_IOASC_SYNC_REQUIRED
) {
5375 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5376 if (!ipr_is_naca_model(res
))
5377 res
->needs_sync_complete
= 1;
5380 return IPR_IOASC_SENSE_KEY(ioasc
) ? FAILED
: SUCCESS
;
5384 * ipr_eh_abort - Abort a single op
5385 * @scsi_cmd: scsi command struct
5388 * 0 if scan in progress / 1 if scan is complete
5390 static int ipr_scan_finished(struct Scsi_Host
*shost
, unsigned long elapsed_time
)
5392 unsigned long lock_flags
;
5393 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*) shost
->hostdata
;
5396 spin_lock_irqsave(shost
->host_lock
, lock_flags
);
5397 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
|| ioa_cfg
->scan_done
)
5399 if ((elapsed_time
/HZ
) > (ioa_cfg
->transop_timeout
* 2))
5401 spin_unlock_irqrestore(shost
->host_lock
, lock_flags
);
5406 * ipr_eh_host_reset - Reset the host adapter
5407 * @scsi_cmd: scsi command struct
5412 static int ipr_eh_abort(struct scsi_cmnd
*scsi_cmd
)
5414 unsigned long flags
;
5416 struct ipr_ioa_cfg
*ioa_cfg
;
5420 ioa_cfg
= (struct ipr_ioa_cfg
*) scsi_cmd
->device
->host
->hostdata
;
5422 spin_lock_irqsave(scsi_cmd
->device
->host
->host_lock
, flags
);
5423 rc
= ipr_cancel_op(scsi_cmd
);
5424 spin_unlock_irqrestore(scsi_cmd
->device
->host
->host_lock
, flags
);
5427 rc
= ipr_wait_for_ops(ioa_cfg
, scsi_cmd
->device
, ipr_match_lun
);
5433 * ipr_handle_other_interrupt - Handle "other" interrupts
5434 * @ioa_cfg: ioa config struct
5435 * @int_reg: interrupt register
5438 * IRQ_NONE / IRQ_HANDLED
5440 static irqreturn_t
ipr_handle_other_interrupt(struct ipr_ioa_cfg
*ioa_cfg
,
5443 irqreturn_t rc
= IRQ_HANDLED
;
5446 int_mask_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg32
);
5447 int_reg
&= ~int_mask_reg
;
5449 /* If an interrupt on the adapter did not occur, ignore it.
5450 * Or in the case of SIS 64, check for a stage change interrupt.
5452 if ((int_reg
& IPR_PCII_OPER_INTERRUPTS
) == 0) {
5453 if (ioa_cfg
->sis64
) {
5454 int_mask_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
5455 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
) & ~int_mask_reg
;
5456 if (int_reg
& IPR_PCII_IPL_STAGE_CHANGE
) {
5458 /* clear stage change */
5459 writel(IPR_PCII_IPL_STAGE_CHANGE
, ioa_cfg
->regs
.clr_interrupt_reg
);
5460 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
) & ~int_mask_reg
;
5461 list_del(&ioa_cfg
->reset_cmd
->queue
);
5462 del_timer(&ioa_cfg
->reset_cmd
->timer
);
5463 ipr_reset_ioa_job(ioa_cfg
->reset_cmd
);
5471 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
5472 /* Mask the interrupt */
5473 writel(IPR_PCII_IOA_TRANS_TO_OPER
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
5474 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
5476 list_del(&ioa_cfg
->reset_cmd
->queue
);
5477 del_timer(&ioa_cfg
->reset_cmd
->timer
);
5478 ipr_reset_ioa_job(ioa_cfg
->reset_cmd
);
5479 } else if ((int_reg
& IPR_PCII_HRRQ_UPDATED
) == int_reg
) {
5480 if (ioa_cfg
->clear_isr
) {
5481 if (ipr_debug
&& printk_ratelimit())
5482 dev_err(&ioa_cfg
->pdev
->dev
,
5483 "Spurious interrupt detected. 0x%08X\n", int_reg
);
5484 writel(IPR_PCII_HRRQ_UPDATED
, ioa_cfg
->regs
.clr_interrupt_reg32
);
5485 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5489 if (int_reg
& IPR_PCII_IOA_UNIT_CHECKED
)
5490 ioa_cfg
->ioa_unit_checked
= 1;
5491 else if (int_reg
& IPR_PCII_NO_HOST_RRQ
)
5492 dev_err(&ioa_cfg
->pdev
->dev
,
5493 "No Host RRQ. 0x%08X\n", int_reg
);
5495 dev_err(&ioa_cfg
->pdev
->dev
,
5496 "Permanent IOA failure. 0x%08X\n", int_reg
);
5498 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5499 ioa_cfg
->sdt_state
= GET_DUMP
;
5501 ipr_mask_and_clear_interrupts(ioa_cfg
, ~0);
5502 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
5509 * ipr_isr_eh - Interrupt service routine error handler
5510 * @ioa_cfg: ioa config struct
5511 * @msg: message to log
5516 static void ipr_isr_eh(struct ipr_ioa_cfg
*ioa_cfg
, char *msg
, u16 number
)
5518 ioa_cfg
->errors_logged
++;
5519 dev_err(&ioa_cfg
->pdev
->dev
, "%s %d\n", msg
, number
);
5521 if (WAIT_FOR_DUMP
== ioa_cfg
->sdt_state
)
5522 ioa_cfg
->sdt_state
= GET_DUMP
;
5524 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
5527 static int ipr_process_hrrq(struct ipr_hrr_queue
*hrr_queue
, int budget
,
5528 struct list_head
*doneq
)
5532 struct ipr_cmnd
*ipr_cmd
;
5533 struct ipr_ioa_cfg
*ioa_cfg
= hrr_queue
->ioa_cfg
;
5536 /* If interrupts are disabled, ignore the interrupt */
5537 if (!hrr_queue
->allow_interrupts
)
5540 while ((be32_to_cpu(*hrr_queue
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5541 hrr_queue
->toggle_bit
) {
5543 cmd_index
= (be32_to_cpu(*hrr_queue
->hrrq_curr
) &
5544 IPR_HRRQ_REQ_RESP_HANDLE_MASK
) >>
5545 IPR_HRRQ_REQ_RESP_HANDLE_SHIFT
;
5547 if (unlikely(cmd_index
> hrr_queue
->max_cmd_id
||
5548 cmd_index
< hrr_queue
->min_cmd_id
)) {
5550 "Invalid response handle from IOA: ",
5555 ipr_cmd
= ioa_cfg
->ipr_cmnd_list
[cmd_index
];
5556 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5558 ipr_trc_hook(ipr_cmd
, IPR_TRACE_FINISH
, ioasc
);
5560 list_move_tail(&ipr_cmd
->queue
, doneq
);
5562 if (hrr_queue
->hrrq_curr
< hrr_queue
->hrrq_end
) {
5563 hrr_queue
->hrrq_curr
++;
5565 hrr_queue
->hrrq_curr
= hrr_queue
->hrrq_start
;
5566 hrr_queue
->toggle_bit
^= 1u;
5569 if (budget
> 0 && num_hrrq
>= budget
)
5576 static int ipr_iopoll(struct irq_poll
*iop
, int budget
)
5578 struct ipr_ioa_cfg
*ioa_cfg
;
5579 struct ipr_hrr_queue
*hrrq
;
5580 struct ipr_cmnd
*ipr_cmd
, *temp
;
5581 unsigned long hrrq_flags
;
5585 hrrq
= container_of(iop
, struct ipr_hrr_queue
, iopoll
);
5586 ioa_cfg
= hrrq
->ioa_cfg
;
5588 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5589 completed_ops
= ipr_process_hrrq(hrrq
, budget
, &doneq
);
5591 if (completed_ops
< budget
)
5592 irq_poll_complete(iop
);
5593 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5595 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5596 list_del(&ipr_cmd
->queue
);
5597 del_timer(&ipr_cmd
->timer
);
5598 ipr_cmd
->fast_done(ipr_cmd
);
5601 return completed_ops
;
5605 * ipr_isr - Interrupt service routine
5607 * @devp: pointer to ioa config struct
5610 * IRQ_NONE / IRQ_HANDLED
5612 static irqreturn_t
ipr_isr(int irq
, void *devp
)
5614 struct ipr_hrr_queue
*hrrq
= (struct ipr_hrr_queue
*)devp
;
5615 struct ipr_ioa_cfg
*ioa_cfg
= hrrq
->ioa_cfg
;
5616 unsigned long hrrq_flags
= 0;
5620 struct ipr_cmnd
*ipr_cmd
, *temp
;
5621 irqreturn_t rc
= IRQ_NONE
;
5624 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5625 /* If interrupts are disabled, ignore the interrupt */
5626 if (!hrrq
->allow_interrupts
) {
5627 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5632 if (ipr_process_hrrq(hrrq
, -1, &doneq
)) {
5635 if (!ioa_cfg
->clear_isr
)
5638 /* Clear the PCI interrupt */
5641 writel(IPR_PCII_HRRQ_UPDATED
,
5642 ioa_cfg
->regs
.clr_interrupt_reg32
);
5643 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5644 } while (int_reg
& IPR_PCII_HRRQ_UPDATED
&&
5645 num_hrrq
++ < IPR_MAX_HRRQ_RETRIES
);
5647 } else if (rc
== IRQ_NONE
&& irq_none
== 0) {
5648 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
5650 } else if (num_hrrq
== IPR_MAX_HRRQ_RETRIES
&&
5651 int_reg
& IPR_PCII_HRRQ_UPDATED
) {
5653 "Error clearing HRRQ: ", num_hrrq
);
5660 if (unlikely(rc
== IRQ_NONE
))
5661 rc
= ipr_handle_other_interrupt(ioa_cfg
, int_reg
);
5663 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5664 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5665 list_del(&ipr_cmd
->queue
);
5666 del_timer(&ipr_cmd
->timer
);
5667 ipr_cmd
->fast_done(ipr_cmd
);
5673 * ipr_isr_mhrrq - Interrupt service routine
5675 * @devp: pointer to ioa config struct
5678 * IRQ_NONE / IRQ_HANDLED
5680 static irqreturn_t
ipr_isr_mhrrq(int irq
, void *devp
)
5682 struct ipr_hrr_queue
*hrrq
= (struct ipr_hrr_queue
*)devp
;
5683 struct ipr_ioa_cfg
*ioa_cfg
= hrrq
->ioa_cfg
;
5684 unsigned long hrrq_flags
= 0;
5685 struct ipr_cmnd
*ipr_cmd
, *temp
;
5686 irqreturn_t rc
= IRQ_NONE
;
5689 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
5691 /* If interrupts are disabled, ignore the interrupt */
5692 if (!hrrq
->allow_interrupts
) {
5693 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5697 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
5698 if ((be32_to_cpu(*hrrq
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5700 irq_poll_sched(&hrrq
->iopoll
);
5701 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5705 if ((be32_to_cpu(*hrrq
->hrrq_curr
) & IPR_HRRQ_TOGGLE_BIT
) ==
5708 if (ipr_process_hrrq(hrrq
, -1, &doneq
))
5712 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
5714 list_for_each_entry_safe(ipr_cmd
, temp
, &doneq
, queue
) {
5715 list_del(&ipr_cmd
->queue
);
5716 del_timer(&ipr_cmd
->timer
);
5717 ipr_cmd
->fast_done(ipr_cmd
);
5723 * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5724 * @ioa_cfg: ioa config struct
5725 * @ipr_cmd: ipr command struct
5728 * 0 on success / -1 on failure
5730 static int ipr_build_ioadl64(struct ipr_ioa_cfg
*ioa_cfg
,
5731 struct ipr_cmnd
*ipr_cmd
)
5734 struct scatterlist
*sg
;
5736 u32 ioadl_flags
= 0;
5737 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5738 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
5739 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ioadl64
;
5741 length
= scsi_bufflen(scsi_cmd
);
5745 nseg
= scsi_dma_map(scsi_cmd
);
5747 if (printk_ratelimit())
5748 dev_err(&ioa_cfg
->pdev
->dev
, "scsi_dma_map failed!\n");
5752 ipr_cmd
->dma_use_sg
= nseg
;
5754 ioarcb
->data_transfer_length
= cpu_to_be32(length
);
5756 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
5758 if (scsi_cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
5759 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
5760 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
5761 } else if (scsi_cmd
->sc_data_direction
== DMA_FROM_DEVICE
)
5762 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
5764 scsi_for_each_sg(scsi_cmd
, sg
, ipr_cmd
->dma_use_sg
, i
) {
5765 ioadl64
[i
].flags
= cpu_to_be32(ioadl_flags
);
5766 ioadl64
[i
].data_len
= cpu_to_be32(sg_dma_len(sg
));
5767 ioadl64
[i
].address
= cpu_to_be64(sg_dma_address(sg
));
5770 ioadl64
[i
-1].flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
5775 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5776 * @ioa_cfg: ioa config struct
5777 * @ipr_cmd: ipr command struct
5780 * 0 on success / -1 on failure
5782 static int ipr_build_ioadl(struct ipr_ioa_cfg
*ioa_cfg
,
5783 struct ipr_cmnd
*ipr_cmd
)
5786 struct scatterlist
*sg
;
5788 u32 ioadl_flags
= 0;
5789 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5790 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
5791 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
5793 length
= scsi_bufflen(scsi_cmd
);
5797 nseg
= scsi_dma_map(scsi_cmd
);
5799 dev_err(&ioa_cfg
->pdev
->dev
, "scsi_dma_map failed!\n");
5803 ipr_cmd
->dma_use_sg
= nseg
;
5805 if (scsi_cmd
->sc_data_direction
== DMA_TO_DEVICE
) {
5806 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
5807 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
5808 ioarcb
->data_transfer_length
= cpu_to_be32(length
);
5810 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
5811 } else if (scsi_cmd
->sc_data_direction
== DMA_FROM_DEVICE
) {
5812 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
5813 ioarcb
->read_data_transfer_length
= cpu_to_be32(length
);
5814 ioarcb
->read_ioadl_len
=
5815 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
5818 if (ipr_cmd
->dma_use_sg
<= ARRAY_SIZE(ioarcb
->u
.add_data
.u
.ioadl
)) {
5819 ioadl
= ioarcb
->u
.add_data
.u
.ioadl
;
5820 ioarcb
->write_ioadl_addr
= cpu_to_be32((ipr_cmd
->dma_addr
) +
5821 offsetof(struct ipr_ioarcb
, u
.add_data
));
5822 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
5825 scsi_for_each_sg(scsi_cmd
, sg
, ipr_cmd
->dma_use_sg
, i
) {
5826 ioadl
[i
].flags_and_data_len
=
5827 cpu_to_be32(ioadl_flags
| sg_dma_len(sg
));
5828 ioadl
[i
].address
= cpu_to_be32(sg_dma_address(sg
));
5831 ioadl
[i
-1].flags_and_data_len
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
5836 * ipr_erp_done - Process completion of ERP for a device
5837 * @ipr_cmd: ipr command struct
5839 * This function copies the sense buffer into the scsi_cmd
5840 * struct and pushes the scsi_done function.
5845 static void ipr_erp_done(struct ipr_cmnd
*ipr_cmd
)
5847 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5848 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
5849 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5851 if (IPR_IOASC_SENSE_KEY(ioasc
) > 0) {
5852 scsi_cmd
->result
|= (DID_ERROR
<< 16);
5853 scmd_printk(KERN_ERR
, scsi_cmd
,
5854 "Request Sense failed with IOASC: 0x%08X\n", ioasc
);
5856 memcpy(scsi_cmd
->sense_buffer
, ipr_cmd
->sense_buffer
,
5857 SCSI_SENSE_BUFFERSIZE
);
5861 if (!ipr_is_naca_model(res
))
5862 res
->needs_sync_complete
= 1;
5865 scsi_dma_unmap(ipr_cmd
->scsi_cmd
);
5866 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
5867 scsi_cmd
->scsi_done(scsi_cmd
);
5871 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
5872 * @ipr_cmd: ipr command struct
5877 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd
*ipr_cmd
)
5879 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
5880 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
5881 dma_addr_t dma_addr
= ipr_cmd
->dma_addr
;
5883 memset(&ioarcb
->cmd_pkt
, 0, sizeof(struct ipr_cmd_pkt
));
5884 ioarcb
->data_transfer_length
= 0;
5885 ioarcb
->read_data_transfer_length
= 0;
5886 ioarcb
->ioadl_len
= 0;
5887 ioarcb
->read_ioadl_len
= 0;
5888 ioasa
->hdr
.ioasc
= 0;
5889 ioasa
->hdr
.residual_data_len
= 0;
5891 if (ipr_cmd
->ioa_cfg
->sis64
)
5892 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
5893 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl64
));
5895 ioarcb
->write_ioadl_addr
=
5896 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl
));
5897 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
5902 * ipr_erp_request_sense - Send request sense to a device
5903 * @ipr_cmd: ipr command struct
5905 * This function sends a request sense to a device as a result
5906 * of a check condition.
5911 static void ipr_erp_request_sense(struct ipr_cmnd
*ipr_cmd
)
5913 struct ipr_cmd_pkt
*cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
5914 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
5916 if (IPR_IOASC_SENSE_KEY(ioasc
) > 0) {
5917 ipr_erp_done(ipr_cmd
);
5921 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd
);
5923 cmd_pkt
->request_type
= IPR_RQTYPE_SCSICDB
;
5924 cmd_pkt
->cdb
[0] = REQUEST_SENSE
;
5925 cmd_pkt
->cdb
[4] = SCSI_SENSE_BUFFERSIZE
;
5926 cmd_pkt
->flags_hi
|= IPR_FLAGS_HI_SYNC_OVERRIDE
;
5927 cmd_pkt
->flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
5928 cmd_pkt
->timeout
= cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT
/ HZ
);
5930 ipr_init_ioadl(ipr_cmd
, ipr_cmd
->sense_buffer_dma
,
5931 SCSI_SENSE_BUFFERSIZE
, IPR_IOADL_FLAGS_READ_LAST
);
5933 ipr_do_req(ipr_cmd
, ipr_erp_done
, ipr_timeout
,
5934 IPR_REQUEST_SENSE_TIMEOUT
* 2);
5938 * ipr_erp_cancel_all - Send cancel all to a device
5939 * @ipr_cmd: ipr command struct
5941 * This function sends a cancel all to a device to clear the
5942 * queue. If we are running TCQ on the device, QERR is set to 1,
5943 * which means all outstanding ops have been dropped on the floor.
5944 * Cancel all will return them to us.
5949 static void ipr_erp_cancel_all(struct ipr_cmnd
*ipr_cmd
)
5951 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
5952 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
5953 struct ipr_cmd_pkt
*cmd_pkt
;
5957 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd
);
5959 if (!scsi_cmd
->device
->simple_tags
) {
5960 ipr_erp_request_sense(ipr_cmd
);
5964 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
5965 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
5966 cmd_pkt
->cdb
[0] = IPR_CANCEL_ALL_REQUESTS
;
5968 ipr_do_req(ipr_cmd
, ipr_erp_request_sense
, ipr_timeout
,
5969 IPR_CANCEL_ALL_TIMEOUT
);
5973 * ipr_dump_ioasa - Dump contents of IOASA
5974 * @ioa_cfg: ioa config struct
5975 * @ipr_cmd: ipr command struct
5976 * @res: resource entry struct
5978 * This function is invoked by the interrupt handler when ops
5979 * fail. It will log the IOASA if appropriate. Only called
5985 static void ipr_dump_ioasa(struct ipr_ioa_cfg
*ioa_cfg
,
5986 struct ipr_cmnd
*ipr_cmd
, struct ipr_resource_entry
*res
)
5990 u32 ioasc
, fd_ioasc
;
5991 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
5992 __be32
*ioasa_data
= (__be32
*)ioasa
;
5995 ioasc
= be32_to_cpu(ioasa
->hdr
.ioasc
) & IPR_IOASC_IOASC_MASK
;
5996 fd_ioasc
= be32_to_cpu(ioasa
->hdr
.fd_ioasc
) & IPR_IOASC_IOASC_MASK
;
6001 if (ioa_cfg
->log_level
< IPR_DEFAULT_LOG_LEVEL
)
6004 if (ioasc
== IPR_IOASC_BUS_WAS_RESET
&& fd_ioasc
)
6005 error_index
= ipr_get_error(fd_ioasc
);
6007 error_index
= ipr_get_error(ioasc
);
6009 if (ioa_cfg
->log_level
< IPR_MAX_LOG_LEVEL
) {
6010 /* Don't log an error if the IOA already logged one */
6011 if (ioasa
->hdr
.ilid
!= 0)
6014 if (!ipr_is_gscsi(res
))
6017 if (ipr_error_table
[error_index
].log_ioasa
== 0)
6021 ipr_res_err(ioa_cfg
, res
, "%s\n", ipr_error_table
[error_index
].error
);
6023 data_len
= be16_to_cpu(ioasa
->hdr
.ret_stat_len
);
6024 if (ioa_cfg
->sis64
&& sizeof(struct ipr_ioasa64
) < data_len
)
6025 data_len
= sizeof(struct ipr_ioasa64
);
6026 else if (!ioa_cfg
->sis64
&& sizeof(struct ipr_ioasa
) < data_len
)
6027 data_len
= sizeof(struct ipr_ioasa
);
6029 ipr_err("IOASA Dump:\n");
6031 for (i
= 0; i
< data_len
/ 4; i
+= 4) {
6032 ipr_err("%08X: %08X %08X %08X %08X\n", i
*4,
6033 be32_to_cpu(ioasa_data
[i
]),
6034 be32_to_cpu(ioasa_data
[i
+1]),
6035 be32_to_cpu(ioasa_data
[i
+2]),
6036 be32_to_cpu(ioasa_data
[i
+3]));
6041 * ipr_gen_sense - Generate SCSI sense data from an IOASA
6043 * @sense_buf: sense data buffer
6048 static void ipr_gen_sense(struct ipr_cmnd
*ipr_cmd
)
6051 u8
*sense_buf
= ipr_cmd
->scsi_cmd
->sense_buffer
;
6052 struct ipr_resource_entry
*res
= ipr_cmd
->scsi_cmd
->device
->hostdata
;
6053 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6054 u32 ioasc
= be32_to_cpu(ioasa
->hdr
.ioasc
);
6056 memset(sense_buf
, 0, SCSI_SENSE_BUFFERSIZE
);
6058 if (ioasc
>= IPR_FIRST_DRIVER_IOASC
)
6061 ipr_cmd
->scsi_cmd
->result
= SAM_STAT_CHECK_CONDITION
;
6063 if (ipr_is_vset_device(res
) &&
6064 ioasc
== IPR_IOASC_MED_DO_NOT_REALLOC
&&
6065 ioasa
->u
.vset
.failing_lba_hi
!= 0) {
6066 sense_buf
[0] = 0x72;
6067 sense_buf
[1] = IPR_IOASC_SENSE_KEY(ioasc
);
6068 sense_buf
[2] = IPR_IOASC_SENSE_CODE(ioasc
);
6069 sense_buf
[3] = IPR_IOASC_SENSE_QUAL(ioasc
);
6073 sense_buf
[9] = 0x0A;
6074 sense_buf
[10] = 0x80;
6076 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_hi
);
6078 sense_buf
[12] = (failing_lba
& 0xff000000) >> 24;
6079 sense_buf
[13] = (failing_lba
& 0x00ff0000) >> 16;
6080 sense_buf
[14] = (failing_lba
& 0x0000ff00) >> 8;
6081 sense_buf
[15] = failing_lba
& 0x000000ff;
6083 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_lo
);
6085 sense_buf
[16] = (failing_lba
& 0xff000000) >> 24;
6086 sense_buf
[17] = (failing_lba
& 0x00ff0000) >> 16;
6087 sense_buf
[18] = (failing_lba
& 0x0000ff00) >> 8;
6088 sense_buf
[19] = failing_lba
& 0x000000ff;
6090 sense_buf
[0] = 0x70;
6091 sense_buf
[2] = IPR_IOASC_SENSE_KEY(ioasc
);
6092 sense_buf
[12] = IPR_IOASC_SENSE_CODE(ioasc
);
6093 sense_buf
[13] = IPR_IOASC_SENSE_QUAL(ioasc
);
6095 /* Illegal request */
6096 if ((IPR_IOASC_SENSE_KEY(ioasc
) == 0x05) &&
6097 (be32_to_cpu(ioasa
->hdr
.ioasc_specific
) & IPR_FIELD_POINTER_VALID
)) {
6098 sense_buf
[7] = 10; /* additional length */
6100 /* IOARCB was in error */
6101 if (IPR_IOASC_SENSE_CODE(ioasc
) == 0x24)
6102 sense_buf
[15] = 0xC0;
6103 else /* Parameter data was invalid */
6104 sense_buf
[15] = 0x80;
6107 ((IPR_FIELD_POINTER_MASK
&
6108 be32_to_cpu(ioasa
->hdr
.ioasc_specific
)) >> 8) & 0xff;
6110 (IPR_FIELD_POINTER_MASK
&
6111 be32_to_cpu(ioasa
->hdr
.ioasc_specific
)) & 0xff;
6113 if (ioasc
== IPR_IOASC_MED_DO_NOT_REALLOC
) {
6114 if (ipr_is_vset_device(res
))
6115 failing_lba
= be32_to_cpu(ioasa
->u
.vset
.failing_lba_lo
);
6117 failing_lba
= be32_to_cpu(ioasa
->u
.dasd
.failing_lba
);
6119 sense_buf
[0] |= 0x80; /* Or in the Valid bit */
6120 sense_buf
[3] = (failing_lba
& 0xff000000) >> 24;
6121 sense_buf
[4] = (failing_lba
& 0x00ff0000) >> 16;
6122 sense_buf
[5] = (failing_lba
& 0x0000ff00) >> 8;
6123 sense_buf
[6] = failing_lba
& 0x000000ff;
6126 sense_buf
[7] = 6; /* additional length */
6132 * ipr_get_autosense - Copy autosense data to sense buffer
6133 * @ipr_cmd: ipr command struct
6135 * This function copies the autosense buffer to the buffer
6136 * in the scsi_cmd, if there is autosense available.
6139 * 1 if autosense was available / 0 if not
6141 static int ipr_get_autosense(struct ipr_cmnd
*ipr_cmd
)
6143 struct ipr_ioasa
*ioasa
= &ipr_cmd
->s
.ioasa
;
6144 struct ipr_ioasa64
*ioasa64
= &ipr_cmd
->s
.ioasa64
;
6146 if ((be32_to_cpu(ioasa
->hdr
.ioasc_specific
) & IPR_AUTOSENSE_VALID
) == 0)
6149 if (ipr_cmd
->ioa_cfg
->sis64
)
6150 memcpy(ipr_cmd
->scsi_cmd
->sense_buffer
, ioasa64
->auto_sense
.data
,
6151 min_t(u16
, be16_to_cpu(ioasa64
->auto_sense
.auto_sense_len
),
6152 SCSI_SENSE_BUFFERSIZE
));
6154 memcpy(ipr_cmd
->scsi_cmd
->sense_buffer
, ioasa
->auto_sense
.data
,
6155 min_t(u16
, be16_to_cpu(ioasa
->auto_sense
.auto_sense_len
),
6156 SCSI_SENSE_BUFFERSIZE
));
6161 * ipr_erp_start - Process an error response for a SCSI op
6162 * @ioa_cfg: ioa config struct
6163 * @ipr_cmd: ipr command struct
6165 * This function determines whether or not to initiate ERP
6166 * on the affected device.
6171 static void ipr_erp_start(struct ipr_ioa_cfg
*ioa_cfg
,
6172 struct ipr_cmnd
*ipr_cmd
)
6174 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6175 struct ipr_resource_entry
*res
= scsi_cmd
->device
->hostdata
;
6176 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6177 u32 masked_ioasc
= ioasc
& IPR_IOASC_IOASC_MASK
;
6180 ipr_scsi_eh_done(ipr_cmd
);
6184 if (!ipr_is_gscsi(res
) && masked_ioasc
!= IPR_IOASC_HW_DEV_BUS_STATUS
)
6185 ipr_gen_sense(ipr_cmd
);
6187 ipr_dump_ioasa(ioa_cfg
, ipr_cmd
, res
);
6189 switch (masked_ioasc
) {
6190 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST
:
6191 if (ipr_is_naca_model(res
))
6192 scsi_cmd
->result
|= (DID_ABORT
<< 16);
6194 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6196 case IPR_IOASC_IR_RESOURCE_HANDLE
:
6197 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA
:
6198 scsi_cmd
->result
|= (DID_NO_CONNECT
<< 16);
6200 case IPR_IOASC_HW_SEL_TIMEOUT
:
6201 scsi_cmd
->result
|= (DID_NO_CONNECT
<< 16);
6202 if (!ipr_is_naca_model(res
))
6203 res
->needs_sync_complete
= 1;
6205 case IPR_IOASC_SYNC_REQUIRED
:
6207 res
->needs_sync_complete
= 1;
6208 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6210 case IPR_IOASC_MED_DO_NOT_REALLOC
: /* prevent retries */
6211 case IPR_IOASA_IR_DUAL_IOA_DISABLED
:
6212 scsi_cmd
->result
|= (DID_PASSTHROUGH
<< 16);
6214 case IPR_IOASC_BUS_WAS_RESET
:
6215 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER
:
6217 * Report the bus reset and ask for a retry. The device
6218 * will give CC/UA the next command.
6220 if (!res
->resetting_device
)
6221 scsi_report_bus_reset(ioa_cfg
->host
, scsi_cmd
->device
->channel
);
6222 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6223 if (!ipr_is_naca_model(res
))
6224 res
->needs_sync_complete
= 1;
6226 case IPR_IOASC_HW_DEV_BUS_STATUS
:
6227 scsi_cmd
->result
|= IPR_IOASC_SENSE_STATUS(ioasc
);
6228 if (IPR_IOASC_SENSE_STATUS(ioasc
) == SAM_STAT_CHECK_CONDITION
) {
6229 if (!ipr_get_autosense(ipr_cmd
)) {
6230 if (!ipr_is_naca_model(res
)) {
6231 ipr_erp_cancel_all(ipr_cmd
);
6236 if (!ipr_is_naca_model(res
))
6237 res
->needs_sync_complete
= 1;
6239 case IPR_IOASC_NR_INIT_CMD_REQUIRED
:
6241 case IPR_IOASC_IR_NON_OPTIMIZED
:
6242 if (res
->raw_mode
) {
6244 scsi_cmd
->result
|= (DID_IMM_RETRY
<< 16);
6246 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6249 if (IPR_IOASC_SENSE_KEY(ioasc
) > RECOVERED_ERROR
)
6250 scsi_cmd
->result
|= (DID_ERROR
<< 16);
6251 if (!ipr_is_vset_device(res
) && !ipr_is_naca_model(res
))
6252 res
->needs_sync_complete
= 1;
6256 scsi_dma_unmap(ipr_cmd
->scsi_cmd
);
6257 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6258 scsi_cmd
->scsi_done(scsi_cmd
);
6262 * ipr_scsi_done - mid-layer done function
6263 * @ipr_cmd: ipr command struct
6265 * This function is invoked by the interrupt handler for
6266 * ops generated by the SCSI mid-layer
6271 static void ipr_scsi_done(struct ipr_cmnd
*ipr_cmd
)
6273 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
6274 struct scsi_cmnd
*scsi_cmd
= ipr_cmd
->scsi_cmd
;
6275 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6276 unsigned long lock_flags
;
6278 scsi_set_resid(scsi_cmd
, be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.residual_data_len
));
6280 if (likely(IPR_IOASC_SENSE_KEY(ioasc
) == 0)) {
6281 scsi_dma_unmap(scsi_cmd
);
6283 spin_lock_irqsave(ipr_cmd
->hrrq
->lock
, lock_flags
);
6284 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6285 scsi_cmd
->scsi_done(scsi_cmd
);
6286 spin_unlock_irqrestore(ipr_cmd
->hrrq
->lock
, lock_flags
);
6288 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
6289 spin_lock(&ipr_cmd
->hrrq
->_lock
);
6290 ipr_erp_start(ioa_cfg
, ipr_cmd
);
6291 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6292 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
6297 * ipr_queuecommand - Queue a mid-layer request
6298 * @shost: scsi host struct
6299 * @scsi_cmd: scsi command struct
6301 * This function queues a request generated by the mid-layer.
6305 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6306 * SCSI_MLQUEUE_HOST_BUSY if host is busy
6308 static int ipr_queuecommand(struct Scsi_Host
*shost
,
6309 struct scsi_cmnd
*scsi_cmd
)
6311 struct ipr_ioa_cfg
*ioa_cfg
;
6312 struct ipr_resource_entry
*res
;
6313 struct ipr_ioarcb
*ioarcb
;
6314 struct ipr_cmnd
*ipr_cmd
;
6315 unsigned long hrrq_flags
, lock_flags
;
6317 struct ipr_hrr_queue
*hrrq
;
6320 ioa_cfg
= (struct ipr_ioa_cfg
*)shost
->hostdata
;
6322 scsi_cmd
->result
= (DID_OK
<< 16);
6323 res
= scsi_cmd
->device
->hostdata
;
6325 if (ipr_is_gata(res
) && res
->sata_port
) {
6326 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
6327 rc
= ata_sas_queuecmd(scsi_cmd
, res
->sata_port
->ap
);
6328 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
6332 hrrq_id
= ipr_get_hrrq_index(ioa_cfg
);
6333 hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
6335 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6337 * We are currently blocking all devices due to a host reset
6338 * We have told the host to stop giving us new requests, but
6339 * ERP ops don't count. FIXME
6341 if (unlikely(!hrrq
->allow_cmds
&& !hrrq
->ioa_is_dead
&& !hrrq
->removing_ioa
)) {
6342 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6343 return SCSI_MLQUEUE_HOST_BUSY
;
6347 * FIXME - Create scsi_set_host_offline interface
6348 * and the ioa_is_dead check can be removed
6350 if (unlikely(hrrq
->ioa_is_dead
|| hrrq
->removing_ioa
|| !res
)) {
6351 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6355 ipr_cmd
= __ipr_get_free_ipr_cmnd(hrrq
);
6356 if (ipr_cmd
== NULL
) {
6357 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6358 return SCSI_MLQUEUE_HOST_BUSY
;
6360 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6362 ipr_init_ipr_cmnd(ipr_cmd
, ipr_scsi_done
);
6363 ioarcb
= &ipr_cmd
->ioarcb
;
6365 memcpy(ioarcb
->cmd_pkt
.cdb
, scsi_cmd
->cmnd
, scsi_cmd
->cmd_len
);
6366 ipr_cmd
->scsi_cmd
= scsi_cmd
;
6367 ipr_cmd
->done
= ipr_scsi_eh_done
;
6369 if (ipr_is_gscsi(res
)) {
6370 if (scsi_cmd
->underflow
== 0)
6371 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6373 if (res
->reset_occurred
) {
6374 res
->reset_occurred
= 0;
6375 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_DELAY_AFTER_RST
;
6379 if (ipr_is_gscsi(res
) || ipr_is_vset_device(res
)) {
6380 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_LINK_DESC
;
6382 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_ALIGNED_BFR
;
6383 if (scsi_cmd
->flags
& SCMD_TAGGED
)
6384 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_SIMPLE_TASK
;
6386 ioarcb
->cmd_pkt
.flags_lo
|= IPR_FLAGS_LO_UNTAGGED_TASK
;
6389 if (scsi_cmd
->cmnd
[0] >= 0xC0 &&
6390 (!ipr_is_gscsi(res
) || scsi_cmd
->cmnd
[0] == IPR_QUERY_RSRC_STATE
)) {
6391 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
6393 if (res
->raw_mode
&& ipr_is_af_dasd_device(res
)) {
6394 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_PIPE
;
6396 if (scsi_cmd
->underflow
== 0)
6397 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6401 rc
= ipr_build_ioadl64(ioa_cfg
, ipr_cmd
);
6403 rc
= ipr_build_ioadl(ioa_cfg
, ipr_cmd
);
6405 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6406 if (unlikely(rc
|| (!hrrq
->allow_cmds
&& !hrrq
->ioa_is_dead
))) {
6407 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_free_q
);
6408 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6410 scsi_dma_unmap(scsi_cmd
);
6411 return SCSI_MLQUEUE_HOST_BUSY
;
6414 if (unlikely(hrrq
->ioa_is_dead
)) {
6415 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_free_q
);
6416 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6417 scsi_dma_unmap(scsi_cmd
);
6421 ioarcb
->res_handle
= res
->res_handle
;
6422 if (res
->needs_sync_complete
) {
6423 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_SYNC_COMPLETE
;
6424 res
->needs_sync_complete
= 0;
6426 list_add_tail(&ipr_cmd
->queue
, &hrrq
->hrrq_pending_q
);
6427 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, IPR_GET_RES_PHYS_LOC(res
));
6428 ipr_send_command(ipr_cmd
);
6429 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6433 spin_lock_irqsave(hrrq
->lock
, hrrq_flags
);
6434 memset(scsi_cmd
->sense_buffer
, 0, SCSI_SENSE_BUFFERSIZE
);
6435 scsi_cmd
->result
= (DID_NO_CONNECT
<< 16);
6436 scsi_cmd
->scsi_done(scsi_cmd
);
6437 spin_unlock_irqrestore(hrrq
->lock
, hrrq_flags
);
6442 * ipr_ioctl - IOCTL handler
6443 * @sdev: scsi device struct
6448 * 0 on success / other on failure
6450 static int ipr_ioctl(struct scsi_device
*sdev
, int cmd
, void __user
*arg
)
6452 struct ipr_resource_entry
*res
;
6454 res
= (struct ipr_resource_entry
*)sdev
->hostdata
;
6455 if (res
&& ipr_is_gata(res
)) {
6456 if (cmd
== HDIO_GET_IDENTITY
)
6458 return ata_sas_scsi_ioctl(res
->sata_port
->ap
, sdev
, cmd
, arg
);
6465 * ipr_info - Get information about the card/driver
6466 * @scsi_host: scsi host struct
6469 * pointer to buffer with description string
6471 static const char *ipr_ioa_info(struct Scsi_Host
*host
)
6473 static char buffer
[512];
6474 struct ipr_ioa_cfg
*ioa_cfg
;
6475 unsigned long lock_flags
= 0;
6477 ioa_cfg
= (struct ipr_ioa_cfg
*) host
->hostdata
;
6479 spin_lock_irqsave(host
->host_lock
, lock_flags
);
6480 sprintf(buffer
, "IBM %X Storage Adapter", ioa_cfg
->type
);
6481 spin_unlock_irqrestore(host
->host_lock
, lock_flags
);
6486 static struct scsi_host_template driver_template
= {
6487 .module
= THIS_MODULE
,
6489 .info
= ipr_ioa_info
,
6491 .queuecommand
= ipr_queuecommand
,
6492 .eh_abort_handler
= ipr_eh_abort
,
6493 .eh_device_reset_handler
= ipr_eh_dev_reset
,
6494 .eh_host_reset_handler
= ipr_eh_host_reset
,
6495 .slave_alloc
= ipr_slave_alloc
,
6496 .slave_configure
= ipr_slave_configure
,
6497 .slave_destroy
= ipr_slave_destroy
,
6498 .scan_finished
= ipr_scan_finished
,
6499 .target_alloc
= ipr_target_alloc
,
6500 .target_destroy
= ipr_target_destroy
,
6501 .change_queue_depth
= ipr_change_queue_depth
,
6502 .bios_param
= ipr_biosparam
,
6503 .can_queue
= IPR_MAX_COMMANDS
,
6505 .sg_tablesize
= IPR_MAX_SGLIST
,
6506 .max_sectors
= IPR_IOA_MAX_SECTORS
,
6507 .cmd_per_lun
= IPR_MAX_CMD_PER_LUN
,
6508 .use_clustering
= ENABLE_CLUSTERING
,
6509 .shost_attrs
= ipr_ioa_attrs
,
6510 .sdev_attrs
= ipr_dev_attrs
,
6511 .proc_name
= IPR_NAME
,
6515 * ipr_ata_phy_reset - libata phy_reset handler
6516 * @ap: ata port to reset
6519 static void ipr_ata_phy_reset(struct ata_port
*ap
)
6521 unsigned long flags
;
6522 struct ipr_sata_port
*sata_port
= ap
->private_data
;
6523 struct ipr_resource_entry
*res
= sata_port
->res
;
6524 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6528 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6529 while (ioa_cfg
->in_reset_reload
) {
6530 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6531 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
6532 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6535 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
)
6538 rc
= ipr_device_reset(ioa_cfg
, res
);
6541 ap
->link
.device
[0].class = ATA_DEV_NONE
;
6545 ap
->link
.device
[0].class = res
->ata_class
;
6546 if (ap
->link
.device
[0].class == ATA_DEV_UNKNOWN
)
6547 ap
->link
.device
[0].class = ATA_DEV_NONE
;
6550 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6555 * ipr_ata_post_internal - Cleanup after an internal command
6556 * @qc: ATA queued command
6561 static void ipr_ata_post_internal(struct ata_queued_cmd
*qc
)
6563 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
6564 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6565 struct ipr_cmnd
*ipr_cmd
;
6566 struct ipr_hrr_queue
*hrrq
;
6567 unsigned long flags
;
6569 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6570 while (ioa_cfg
->in_reset_reload
) {
6571 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6572 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
6573 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
6576 for_each_hrrq(hrrq
, ioa_cfg
) {
6577 spin_lock(&hrrq
->_lock
);
6578 list_for_each_entry(ipr_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
6579 if (ipr_cmd
->qc
== qc
) {
6580 ipr_device_reset(ioa_cfg
, sata_port
->res
);
6584 spin_unlock(&hrrq
->_lock
);
6586 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
6590 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6591 * @regs: destination
6592 * @tf: source ATA taskfile
6597 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs
*regs
,
6598 struct ata_taskfile
*tf
)
6600 regs
->feature
= tf
->feature
;
6601 regs
->nsect
= tf
->nsect
;
6602 regs
->lbal
= tf
->lbal
;
6603 regs
->lbam
= tf
->lbam
;
6604 regs
->lbah
= tf
->lbah
;
6605 regs
->device
= tf
->device
;
6606 regs
->command
= tf
->command
;
6607 regs
->hob_feature
= tf
->hob_feature
;
6608 regs
->hob_nsect
= tf
->hob_nsect
;
6609 regs
->hob_lbal
= tf
->hob_lbal
;
6610 regs
->hob_lbam
= tf
->hob_lbam
;
6611 regs
->hob_lbah
= tf
->hob_lbah
;
6612 regs
->ctl
= tf
->ctl
;
6616 * ipr_sata_done - done function for SATA commands
6617 * @ipr_cmd: ipr command struct
6619 * This function is invoked by the interrupt handler for
6620 * ops generated by the SCSI mid-layer to SATA devices
6625 static void ipr_sata_done(struct ipr_cmnd
*ipr_cmd
)
6627 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
6628 struct ata_queued_cmd
*qc
= ipr_cmd
->qc
;
6629 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
6630 struct ipr_resource_entry
*res
= sata_port
->res
;
6631 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
6633 spin_lock(&ipr_cmd
->hrrq
->_lock
);
6634 if (ipr_cmd
->ioa_cfg
->sis64
)
6635 memcpy(&sata_port
->ioasa
, &ipr_cmd
->s
.ioasa64
.u
.gata
,
6636 sizeof(struct ipr_ioasa_gata
));
6638 memcpy(&sata_port
->ioasa
, &ipr_cmd
->s
.ioasa
.u
.gata
,
6639 sizeof(struct ipr_ioasa_gata
));
6640 ipr_dump_ioasa(ioa_cfg
, ipr_cmd
, res
);
6642 if (be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc_specific
) & IPR_ATA_DEVICE_WAS_RESET
)
6643 scsi_report_device_reset(ioa_cfg
->host
, res
->bus
, res
->target
);
6645 if (IPR_IOASC_SENSE_KEY(ioasc
) > RECOVERED_ERROR
)
6646 qc
->err_mask
|= __ac_err_mask(sata_port
->ioasa
.status
);
6648 qc
->err_mask
|= ac_err_mask(sata_port
->ioasa
.status
);
6649 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6650 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6651 ata_qc_complete(qc
);
6655 * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6656 * @ipr_cmd: ipr command struct
6657 * @qc: ATA queued command
6660 static void ipr_build_ata_ioadl64(struct ipr_cmnd
*ipr_cmd
,
6661 struct ata_queued_cmd
*qc
)
6663 u32 ioadl_flags
= 0;
6664 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
6665 struct ipr_ioadl64_desc
*ioadl64
= ipr_cmd
->i
.ata_ioadl
.ioadl64
;
6666 struct ipr_ioadl64_desc
*last_ioadl64
= NULL
;
6667 int len
= qc
->nbytes
;
6668 struct scatterlist
*sg
;
6670 dma_addr_t dma_addr
= ipr_cmd
->dma_addr
;
6675 if (qc
->dma_dir
== DMA_TO_DEVICE
) {
6676 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
6677 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
6678 } else if (qc
->dma_dir
== DMA_FROM_DEVICE
)
6679 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
6681 ioarcb
->data_transfer_length
= cpu_to_be32(len
);
6683 cpu_to_be32(sizeof(struct ipr_ioadl64_desc
) * ipr_cmd
->dma_use_sg
);
6684 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
6685 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ata_ioadl
.ioadl64
));
6687 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
) {
6688 ioadl64
->flags
= cpu_to_be32(ioadl_flags
);
6689 ioadl64
->data_len
= cpu_to_be32(sg_dma_len(sg
));
6690 ioadl64
->address
= cpu_to_be64(sg_dma_address(sg
));
6692 last_ioadl64
= ioadl64
;
6696 if (likely(last_ioadl64
))
6697 last_ioadl64
->flags
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
6701 * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6702 * @ipr_cmd: ipr command struct
6703 * @qc: ATA queued command
6706 static void ipr_build_ata_ioadl(struct ipr_cmnd
*ipr_cmd
,
6707 struct ata_queued_cmd
*qc
)
6709 u32 ioadl_flags
= 0;
6710 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
6711 struct ipr_ioadl_desc
*ioadl
= ipr_cmd
->i
.ioadl
;
6712 struct ipr_ioadl_desc
*last_ioadl
= NULL
;
6713 int len
= qc
->nbytes
;
6714 struct scatterlist
*sg
;
6720 if (qc
->dma_dir
== DMA_TO_DEVICE
) {
6721 ioadl_flags
= IPR_IOADL_FLAGS_WRITE
;
6722 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
6723 ioarcb
->data_transfer_length
= cpu_to_be32(len
);
6725 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
6726 } else if (qc
->dma_dir
== DMA_FROM_DEVICE
) {
6727 ioadl_flags
= IPR_IOADL_FLAGS_READ
;
6728 ioarcb
->read_data_transfer_length
= cpu_to_be32(len
);
6729 ioarcb
->read_ioadl_len
=
6730 cpu_to_be32(sizeof(struct ipr_ioadl_desc
) * ipr_cmd
->dma_use_sg
);
6733 for_each_sg(qc
->sg
, sg
, qc
->n_elem
, si
) {
6734 ioadl
->flags_and_data_len
= cpu_to_be32(ioadl_flags
| sg_dma_len(sg
));
6735 ioadl
->address
= cpu_to_be32(sg_dma_address(sg
));
6741 if (likely(last_ioadl
))
6742 last_ioadl
->flags_and_data_len
|= cpu_to_be32(IPR_IOADL_FLAGS_LAST
);
6746 * ipr_qc_defer - Get a free ipr_cmd
6747 * @qc: queued command
6752 static int ipr_qc_defer(struct ata_queued_cmd
*qc
)
6754 struct ata_port
*ap
= qc
->ap
;
6755 struct ipr_sata_port
*sata_port
= ap
->private_data
;
6756 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6757 struct ipr_cmnd
*ipr_cmd
;
6758 struct ipr_hrr_queue
*hrrq
;
6761 hrrq_id
= ipr_get_hrrq_index(ioa_cfg
);
6762 hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
6764 qc
->lldd_task
= NULL
;
6765 spin_lock(&hrrq
->_lock
);
6766 if (unlikely(hrrq
->ioa_is_dead
)) {
6767 spin_unlock(&hrrq
->_lock
);
6771 if (unlikely(!hrrq
->allow_cmds
)) {
6772 spin_unlock(&hrrq
->_lock
);
6773 return ATA_DEFER_LINK
;
6776 ipr_cmd
= __ipr_get_free_ipr_cmnd(hrrq
);
6777 if (ipr_cmd
== NULL
) {
6778 spin_unlock(&hrrq
->_lock
);
6779 return ATA_DEFER_LINK
;
6782 qc
->lldd_task
= ipr_cmd
;
6783 spin_unlock(&hrrq
->_lock
);
6788 * ipr_qc_issue - Issue a SATA qc to a device
6789 * @qc: queued command
6794 static unsigned int ipr_qc_issue(struct ata_queued_cmd
*qc
)
6796 struct ata_port
*ap
= qc
->ap
;
6797 struct ipr_sata_port
*sata_port
= ap
->private_data
;
6798 struct ipr_resource_entry
*res
= sata_port
->res
;
6799 struct ipr_ioa_cfg
*ioa_cfg
= sata_port
->ioa_cfg
;
6800 struct ipr_cmnd
*ipr_cmd
;
6801 struct ipr_ioarcb
*ioarcb
;
6802 struct ipr_ioarcb_ata_regs
*regs
;
6804 if (qc
->lldd_task
== NULL
)
6807 ipr_cmd
= qc
->lldd_task
;
6808 if (ipr_cmd
== NULL
)
6809 return AC_ERR_SYSTEM
;
6811 qc
->lldd_task
= NULL
;
6812 spin_lock(&ipr_cmd
->hrrq
->_lock
);
6813 if (unlikely(!ipr_cmd
->hrrq
->allow_cmds
||
6814 ipr_cmd
->hrrq
->ioa_is_dead
)) {
6815 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
6816 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6817 return AC_ERR_SYSTEM
;
6820 ipr_init_ipr_cmnd(ipr_cmd
, ipr_lock_and_done
);
6821 ioarcb
= &ipr_cmd
->ioarcb
;
6823 if (ioa_cfg
->sis64
) {
6824 regs
= &ipr_cmd
->i
.ata_ioadl
.regs
;
6825 ioarcb
->add_cmd_parms_offset
= cpu_to_be16(sizeof(*ioarcb
));
6827 regs
= &ioarcb
->u
.add_data
.u
.regs
;
6829 memset(regs
, 0, sizeof(*regs
));
6830 ioarcb
->add_cmd_parms_len
= cpu_to_be16(sizeof(*regs
));
6832 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
6834 ipr_cmd
->done
= ipr_sata_done
;
6835 ipr_cmd
->ioarcb
.res_handle
= res
->res_handle
;
6836 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_ATA_PASSTHRU
;
6837 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_LINK_DESC
;
6838 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_NO_ULEN_CHK
;
6839 ipr_cmd
->dma_use_sg
= qc
->n_elem
;
6842 ipr_build_ata_ioadl64(ipr_cmd
, qc
);
6844 ipr_build_ata_ioadl(ipr_cmd
, qc
);
6846 regs
->flags
|= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION
;
6847 ipr_copy_sata_tf(regs
, &qc
->tf
);
6848 memcpy(ioarcb
->cmd_pkt
.cdb
, qc
->cdb
, IPR_MAX_CDB_LEN
);
6849 ipr_trc_hook(ipr_cmd
, IPR_TRACE_START
, IPR_GET_RES_PHYS_LOC(res
));
6851 switch (qc
->tf
.protocol
) {
6852 case ATA_PROT_NODATA
:
6857 regs
->flags
|= IPR_ATA_FLAG_XFER_TYPE_DMA
;
6860 case ATAPI_PROT_PIO
:
6861 case ATAPI_PROT_NODATA
:
6862 regs
->flags
|= IPR_ATA_FLAG_PACKET_CMD
;
6865 case ATAPI_PROT_DMA
:
6866 regs
->flags
|= IPR_ATA_FLAG_PACKET_CMD
;
6867 regs
->flags
|= IPR_ATA_FLAG_XFER_TYPE_DMA
;
6872 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6873 return AC_ERR_INVALID
;
6876 ipr_send_command(ipr_cmd
);
6877 spin_unlock(&ipr_cmd
->hrrq
->_lock
);
6883 * ipr_qc_fill_rtf - Read result TF
6884 * @qc: ATA queued command
6889 static bool ipr_qc_fill_rtf(struct ata_queued_cmd
*qc
)
6891 struct ipr_sata_port
*sata_port
= qc
->ap
->private_data
;
6892 struct ipr_ioasa_gata
*g
= &sata_port
->ioasa
;
6893 struct ata_taskfile
*tf
= &qc
->result_tf
;
6895 tf
->feature
= g
->error
;
6896 tf
->nsect
= g
->nsect
;
6900 tf
->device
= g
->device
;
6901 tf
->command
= g
->status
;
6902 tf
->hob_nsect
= g
->hob_nsect
;
6903 tf
->hob_lbal
= g
->hob_lbal
;
6904 tf
->hob_lbam
= g
->hob_lbam
;
6905 tf
->hob_lbah
= g
->hob_lbah
;
6910 static struct ata_port_operations ipr_sata_ops
= {
6911 .phy_reset
= ipr_ata_phy_reset
,
6912 .hardreset
= ipr_sata_reset
,
6913 .post_internal_cmd
= ipr_ata_post_internal
,
6914 .qc_prep
= ata_noop_qc_prep
,
6915 .qc_defer
= ipr_qc_defer
,
6916 .qc_issue
= ipr_qc_issue
,
6917 .qc_fill_rtf
= ipr_qc_fill_rtf
,
6918 .port_start
= ata_sas_port_start
,
6919 .port_stop
= ata_sas_port_stop
6922 static struct ata_port_info sata_port_info
= {
6923 .flags
= ATA_FLAG_SATA
| ATA_FLAG_PIO_DMA
|
6925 .pio_mask
= ATA_PIO4_ONLY
,
6926 .mwdma_mask
= ATA_MWDMA2
,
6927 .udma_mask
= ATA_UDMA6
,
6928 .port_ops
= &ipr_sata_ops
6931 #ifdef CONFIG_PPC_PSERIES
6932 static const u16 ipr_blocked_processors
[] = {
6944 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
6945 * @ioa_cfg: ioa cfg struct
6947 * Adapters that use Gemstone revision < 3.1 do not work reliably on
6948 * certain pSeries hardware. This function determines if the given
6949 * adapter is in one of these confgurations or not.
6952 * 1 if adapter is not supported / 0 if adapter is supported
6954 static int ipr_invalid_adapter(struct ipr_ioa_cfg
*ioa_cfg
)
6958 if ((ioa_cfg
->type
== 0x5702) && (ioa_cfg
->pdev
->revision
< 4)) {
6959 for (i
= 0; i
< ARRAY_SIZE(ipr_blocked_processors
); i
++) {
6960 if (pvr_version_is(ipr_blocked_processors
[i
]))
6967 #define ipr_invalid_adapter(ioa_cfg) 0
6971 * ipr_ioa_bringdown_done - IOA bring down completion.
6972 * @ipr_cmd: ipr command struct
6974 * This function processes the completion of an adapter bring down.
6975 * It wakes any reset sleepers.
6980 static int ipr_ioa_bringdown_done(struct ipr_cmnd
*ipr_cmd
)
6982 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
6986 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
) {
6988 spin_unlock_irq(ioa_cfg
->host
->host_lock
);
6989 scsi_unblock_requests(ioa_cfg
->host
);
6990 spin_lock_irq(ioa_cfg
->host
->host_lock
);
6993 ioa_cfg
->in_reset_reload
= 0;
6994 ioa_cfg
->reset_retries
= 0;
6995 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
6996 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
6997 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 1;
6998 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
7002 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7003 wake_up_all(&ioa_cfg
->reset_wait_q
);
7006 return IPR_RC_JOB_RETURN
;
7010 * ipr_ioa_reset_done - IOA reset completion.
7011 * @ipr_cmd: ipr command struct
7013 * This function processes the completion of an adapter reset.
7014 * It schedules any necessary mid-layer add/removes and
7015 * wakes any reset sleepers.
7020 static int ipr_ioa_reset_done(struct ipr_cmnd
*ipr_cmd
)
7022 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7023 struct ipr_resource_entry
*res
;
7024 struct ipr_hostrcb
*hostrcb
, *temp
;
7028 ioa_cfg
->in_reset_reload
= 0;
7029 for (j
= 0; j
< ioa_cfg
->hrrq_num
; j
++) {
7030 spin_lock(&ioa_cfg
->hrrq
[j
]._lock
);
7031 ioa_cfg
->hrrq
[j
].allow_cmds
= 1;
7032 spin_unlock(&ioa_cfg
->hrrq
[j
]._lock
);
7035 ioa_cfg
->reset_cmd
= NULL
;
7036 ioa_cfg
->doorbell
|= IPR_RUNTIME_RESET
;
7038 list_for_each_entry(res
, &ioa_cfg
->used_res_q
, queue
) {
7039 if (res
->add_to_ml
|| res
->del_from_ml
) {
7044 schedule_work(&ioa_cfg
->work_q
);
7046 list_for_each_entry_safe(hostrcb
, temp
, &ioa_cfg
->hostrcb_free_q
, queue
) {
7047 list_del(&hostrcb
->queue
);
7048 if (i
++ < IPR_NUM_LOG_HCAMS
)
7049 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_LOG_DATA
, hostrcb
);
7051 ipr_send_hcam(ioa_cfg
, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE
, hostrcb
);
7054 scsi_report_bus_reset(ioa_cfg
->host
, IPR_VSET_BUS
);
7055 dev_info(&ioa_cfg
->pdev
->dev
, "IOA initialized.\n");
7057 ioa_cfg
->reset_retries
= 0;
7058 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7059 wake_up_all(&ioa_cfg
->reset_wait_q
);
7061 spin_unlock(ioa_cfg
->host
->host_lock
);
7062 scsi_unblock_requests(ioa_cfg
->host
);
7063 spin_lock(ioa_cfg
->host
->host_lock
);
7065 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
)
7066 scsi_block_requests(ioa_cfg
->host
);
7068 schedule_work(&ioa_cfg
->work_q
);
7070 return IPR_RC_JOB_RETURN
;
7074 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7075 * @supported_dev: supported device struct
7076 * @vpids: vendor product id struct
7081 static void ipr_set_sup_dev_dflt(struct ipr_supported_device
*supported_dev
,
7082 struct ipr_std_inq_vpids
*vpids
)
7084 memset(supported_dev
, 0, sizeof(struct ipr_supported_device
));
7085 memcpy(&supported_dev
->vpids
, vpids
, sizeof(struct ipr_std_inq_vpids
));
7086 supported_dev
->num_records
= 1;
7087 supported_dev
->data_length
=
7088 cpu_to_be16(sizeof(struct ipr_supported_device
));
7089 supported_dev
->reserved
= 0;
7093 * ipr_set_supported_devs - Send Set Supported Devices for a device
7094 * @ipr_cmd: ipr command struct
7096 * This function sends a Set Supported Devices to the adapter
7099 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7101 static int ipr_set_supported_devs(struct ipr_cmnd
*ipr_cmd
)
7103 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7104 struct ipr_supported_device
*supp_dev
= &ioa_cfg
->vpd_cbs
->supp_dev
;
7105 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7106 struct ipr_resource_entry
*res
= ipr_cmd
->u
.res
;
7108 ipr_cmd
->job_step
= ipr_ioa_reset_done
;
7110 list_for_each_entry_continue(res
, &ioa_cfg
->used_res_q
, queue
) {
7111 if (!ipr_is_scsi_disk(res
))
7114 ipr_cmd
->u
.res
= res
;
7115 ipr_set_sup_dev_dflt(supp_dev
, &res
->std_inq_data
.vpids
);
7117 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7118 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
7119 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7121 ioarcb
->cmd_pkt
.cdb
[0] = IPR_SET_SUPPORTED_DEVICES
;
7122 ioarcb
->cmd_pkt
.cdb
[1] = IPR_SET_ALL_SUPPORTED_DEVICES
;
7123 ioarcb
->cmd_pkt
.cdb
[7] = (sizeof(struct ipr_supported_device
) >> 8) & 0xff;
7124 ioarcb
->cmd_pkt
.cdb
[8] = sizeof(struct ipr_supported_device
) & 0xff;
7126 ipr_init_ioadl(ipr_cmd
,
7127 ioa_cfg
->vpd_cbs_dma
+
7128 offsetof(struct ipr_misc_cbs
, supp_dev
),
7129 sizeof(struct ipr_supported_device
),
7130 IPR_IOADL_FLAGS_WRITE_LAST
);
7132 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
7133 IPR_SET_SUP_DEVICE_TIMEOUT
);
7135 if (!ioa_cfg
->sis64
)
7136 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7138 return IPR_RC_JOB_RETURN
;
7142 return IPR_RC_JOB_CONTINUE
;
7146 * ipr_get_mode_page - Locate specified mode page
7147 * @mode_pages: mode page buffer
7148 * @page_code: page code to find
7149 * @len: minimum required length for mode page
7152 * pointer to mode page / NULL on failure
7154 static void *ipr_get_mode_page(struct ipr_mode_pages
*mode_pages
,
7155 u32 page_code
, u32 len
)
7157 struct ipr_mode_page_hdr
*mode_hdr
;
7161 if (!mode_pages
|| (mode_pages
->hdr
.length
== 0))
7164 length
= (mode_pages
->hdr
.length
+ 1) - 4 - mode_pages
->hdr
.block_desc_len
;
7165 mode_hdr
= (struct ipr_mode_page_hdr
*)
7166 (mode_pages
->data
+ mode_pages
->hdr
.block_desc_len
);
7169 if (IPR_GET_MODE_PAGE_CODE(mode_hdr
) == page_code
) {
7170 if (mode_hdr
->page_length
>= (len
- sizeof(struct ipr_mode_page_hdr
)))
7174 page_length
= (sizeof(struct ipr_mode_page_hdr
) +
7175 mode_hdr
->page_length
);
7176 length
-= page_length
;
7177 mode_hdr
= (struct ipr_mode_page_hdr
*)
7178 ((unsigned long)mode_hdr
+ page_length
);
7185 * ipr_check_term_power - Check for term power errors
7186 * @ioa_cfg: ioa config struct
7187 * @mode_pages: IOAFP mode pages buffer
7189 * Check the IOAFP's mode page 28 for term power errors
7194 static void ipr_check_term_power(struct ipr_ioa_cfg
*ioa_cfg
,
7195 struct ipr_mode_pages
*mode_pages
)
7199 struct ipr_dev_bus_entry
*bus
;
7200 struct ipr_mode_page28
*mode_page
;
7202 mode_page
= ipr_get_mode_page(mode_pages
, 0x28,
7203 sizeof(struct ipr_mode_page28
));
7205 entry_length
= mode_page
->entry_length
;
7207 bus
= mode_page
->bus
;
7209 for (i
= 0; i
< mode_page
->num_entries
; i
++) {
7210 if (bus
->flags
& IPR_SCSI_ATTR_NO_TERM_PWR
) {
7211 dev_err(&ioa_cfg
->pdev
->dev
,
7212 "Term power is absent on scsi bus %d\n",
7216 bus
= (struct ipr_dev_bus_entry
*)((char *)bus
+ entry_length
);
7221 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7222 * @ioa_cfg: ioa config struct
7224 * Looks through the config table checking for SES devices. If
7225 * the SES device is in the SES table indicating a maximum SCSI
7226 * bus speed, the speed is limited for the bus.
7231 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg
*ioa_cfg
)
7236 for (i
= 0; i
< IPR_MAX_NUM_BUSES
; i
++) {
7237 max_xfer_rate
= ipr_get_max_scsi_speed(ioa_cfg
, i
,
7238 ioa_cfg
->bus_attr
[i
].bus_width
);
7240 if (max_xfer_rate
< ioa_cfg
->bus_attr
[i
].max_xfer_rate
)
7241 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= max_xfer_rate
;
7246 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7247 * @ioa_cfg: ioa config struct
7248 * @mode_pages: mode page 28 buffer
7250 * Updates mode page 28 based on driver configuration
7255 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg
*ioa_cfg
,
7256 struct ipr_mode_pages
*mode_pages
)
7258 int i
, entry_length
;
7259 struct ipr_dev_bus_entry
*bus
;
7260 struct ipr_bus_attributes
*bus_attr
;
7261 struct ipr_mode_page28
*mode_page
;
7263 mode_page
= ipr_get_mode_page(mode_pages
, 0x28,
7264 sizeof(struct ipr_mode_page28
));
7266 entry_length
= mode_page
->entry_length
;
7268 /* Loop for each device bus entry */
7269 for (i
= 0, bus
= mode_page
->bus
;
7270 i
< mode_page
->num_entries
;
7271 i
++, bus
= (struct ipr_dev_bus_entry
*)((u8
*)bus
+ entry_length
)) {
7272 if (bus
->res_addr
.bus
> IPR_MAX_NUM_BUSES
) {
7273 dev_err(&ioa_cfg
->pdev
->dev
,
7274 "Invalid resource address reported: 0x%08X\n",
7275 IPR_GET_PHYS_LOC(bus
->res_addr
));
7279 bus_attr
= &ioa_cfg
->bus_attr
[i
];
7280 bus
->extended_reset_delay
= IPR_EXTENDED_RESET_DELAY
;
7281 bus
->bus_width
= bus_attr
->bus_width
;
7282 bus
->max_xfer_rate
= cpu_to_be32(bus_attr
->max_xfer_rate
);
7283 bus
->flags
&= ~IPR_SCSI_ATTR_QAS_MASK
;
7284 if (bus_attr
->qas_enabled
)
7285 bus
->flags
|= IPR_SCSI_ATTR_ENABLE_QAS
;
7287 bus
->flags
|= IPR_SCSI_ATTR_DISABLE_QAS
;
7292 * ipr_build_mode_select - Build a mode select command
7293 * @ipr_cmd: ipr command struct
7294 * @res_handle: resource handle to send command to
7295 * @parm: Byte 2 of Mode Sense command
7296 * @dma_addr: DMA buffer address
7297 * @xfer_len: data transfer length
7302 static void ipr_build_mode_select(struct ipr_cmnd
*ipr_cmd
,
7303 __be32 res_handle
, u8 parm
,
7304 dma_addr_t dma_addr
, u8 xfer_len
)
7306 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7308 ioarcb
->res_handle
= res_handle
;
7309 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7310 ioarcb
->cmd_pkt
.flags_hi
|= IPR_FLAGS_HI_WRITE_NOT_READ
;
7311 ioarcb
->cmd_pkt
.cdb
[0] = MODE_SELECT
;
7312 ioarcb
->cmd_pkt
.cdb
[1] = parm
;
7313 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7315 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_WRITE_LAST
);
7319 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7320 * @ipr_cmd: ipr command struct
7322 * This function sets up the SCSI bus attributes and sends
7323 * a Mode Select for Page 28 to activate them.
7328 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd
*ipr_cmd
)
7330 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7331 struct ipr_mode_pages
*mode_pages
= &ioa_cfg
->vpd_cbs
->mode_pages
;
7335 ipr_scsi_bus_speed_limit(ioa_cfg
);
7336 ipr_check_term_power(ioa_cfg
, mode_pages
);
7337 ipr_modify_ioafp_mode_page_28(ioa_cfg
, mode_pages
);
7338 length
= mode_pages
->hdr
.length
+ 1;
7339 mode_pages
->hdr
.length
= 0;
7341 ipr_build_mode_select(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
), 0x11,
7342 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, mode_pages
),
7345 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7346 ipr_cmd
->u
.res
= list_entry(ioa_cfg
->used_res_q
.next
,
7347 struct ipr_resource_entry
, queue
);
7348 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7351 return IPR_RC_JOB_RETURN
;
7355 * ipr_build_mode_sense - Builds a mode sense command
7356 * @ipr_cmd: ipr command struct
7357 * @res: resource entry struct
7358 * @parm: Byte 2 of mode sense command
7359 * @dma_addr: DMA address of mode sense buffer
7360 * @xfer_len: Size of DMA buffer
7365 static void ipr_build_mode_sense(struct ipr_cmnd
*ipr_cmd
,
7367 u8 parm
, dma_addr_t dma_addr
, u8 xfer_len
)
7369 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7371 ioarcb
->res_handle
= res_handle
;
7372 ioarcb
->cmd_pkt
.cdb
[0] = MODE_SENSE
;
7373 ioarcb
->cmd_pkt
.cdb
[2] = parm
;
7374 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7375 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7377 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_READ_LAST
);
7381 * ipr_reset_cmd_failed - Handle failure of IOA reset command
7382 * @ipr_cmd: ipr command struct
7384 * This function handles the failure of an IOA bringup command.
7389 static int ipr_reset_cmd_failed(struct ipr_cmnd
*ipr_cmd
)
7391 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7392 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7394 dev_err(&ioa_cfg
->pdev
->dev
,
7395 "0x%02X failed with IOASC: 0x%08X\n",
7396 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0], ioasc
);
7398 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
7399 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
7400 return IPR_RC_JOB_RETURN
;
7404 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7405 * @ipr_cmd: ipr command struct
7407 * This function handles the failure of a Mode Sense to the IOAFP.
7408 * Some adapters do not handle all mode pages.
7411 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7413 static int ipr_reset_mode_sense_failed(struct ipr_cmnd
*ipr_cmd
)
7415 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7416 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7418 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
) {
7419 ipr_cmd
->job_step
= ipr_set_supported_devs
;
7420 ipr_cmd
->u
.res
= list_entry(ioa_cfg
->used_res_q
.next
,
7421 struct ipr_resource_entry
, queue
);
7422 return IPR_RC_JOB_CONTINUE
;
7425 return ipr_reset_cmd_failed(ipr_cmd
);
7429 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7430 * @ipr_cmd: ipr command struct
7432 * This function send a Page 28 mode sense to the IOA to
7433 * retrieve SCSI bus attributes.
7438 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd
*ipr_cmd
)
7440 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7443 ipr_build_mode_sense(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
),
7444 0x28, ioa_cfg
->vpd_cbs_dma
+
7445 offsetof(struct ipr_misc_cbs
, mode_pages
),
7446 sizeof(struct ipr_mode_pages
));
7448 ipr_cmd
->job_step
= ipr_ioafp_mode_select_page28
;
7449 ipr_cmd
->job_step_failed
= ipr_reset_mode_sense_failed
;
7451 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7454 return IPR_RC_JOB_RETURN
;
7458 * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7459 * @ipr_cmd: ipr command struct
7461 * This function enables dual IOA RAID support if possible.
7466 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd
*ipr_cmd
)
7468 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7469 struct ipr_mode_pages
*mode_pages
= &ioa_cfg
->vpd_cbs
->mode_pages
;
7470 struct ipr_mode_page24
*mode_page
;
7474 mode_page
= ipr_get_mode_page(mode_pages
, 0x24,
7475 sizeof(struct ipr_mode_page24
));
7478 mode_page
->flags
|= IPR_ENABLE_DUAL_IOA_AF
;
7480 length
= mode_pages
->hdr
.length
+ 1;
7481 mode_pages
->hdr
.length
= 0;
7483 ipr_build_mode_select(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
), 0x11,
7484 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, mode_pages
),
7487 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7488 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7491 return IPR_RC_JOB_RETURN
;
7495 * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7496 * @ipr_cmd: ipr command struct
7498 * This function handles the failure of a Mode Sense to the IOAFP.
7499 * Some adapters do not handle all mode pages.
7502 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7504 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd
*ipr_cmd
)
7506 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7508 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
) {
7509 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7510 return IPR_RC_JOB_CONTINUE
;
7513 return ipr_reset_cmd_failed(ipr_cmd
);
7517 * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7518 * @ipr_cmd: ipr command struct
7520 * This function send a mode sense to the IOA to retrieve
7521 * the IOA Advanced Function Control mode page.
7526 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd
*ipr_cmd
)
7528 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7531 ipr_build_mode_sense(ipr_cmd
, cpu_to_be32(IPR_IOA_RES_HANDLE
),
7532 0x24, ioa_cfg
->vpd_cbs_dma
+
7533 offsetof(struct ipr_misc_cbs
, mode_pages
),
7534 sizeof(struct ipr_mode_pages
));
7536 ipr_cmd
->job_step
= ipr_ioafp_mode_select_page24
;
7537 ipr_cmd
->job_step_failed
= ipr_reset_mode_sense_page24_failed
;
7539 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7542 return IPR_RC_JOB_RETURN
;
7546 * ipr_init_res_table - Initialize the resource table
7547 * @ipr_cmd: ipr command struct
7549 * This function looks through the existing resource table, comparing
7550 * it with the config table. This function will take care of old/new
7551 * devices and schedule adding/removing them from the mid-layer
7555 * IPR_RC_JOB_CONTINUE
7557 static int ipr_init_res_table(struct ipr_cmnd
*ipr_cmd
)
7559 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7560 struct ipr_resource_entry
*res
, *temp
;
7561 struct ipr_config_table_entry_wrapper cfgtew
;
7562 int entries
, found
, flag
, i
;
7567 flag
= ioa_cfg
->u
.cfg_table64
->hdr64
.flags
;
7569 flag
= ioa_cfg
->u
.cfg_table
->hdr
.flags
;
7571 if (flag
& IPR_UCODE_DOWNLOAD_REQ
)
7572 dev_err(&ioa_cfg
->pdev
->dev
, "Microcode download required\n");
7574 list_for_each_entry_safe(res
, temp
, &ioa_cfg
->used_res_q
, queue
)
7575 list_move_tail(&res
->queue
, &old_res
);
7578 entries
= be16_to_cpu(ioa_cfg
->u
.cfg_table64
->hdr64
.num_entries
);
7580 entries
= ioa_cfg
->u
.cfg_table
->hdr
.num_entries
;
7582 for (i
= 0; i
< entries
; i
++) {
7584 cfgtew
.u
.cfgte64
= &ioa_cfg
->u
.cfg_table64
->dev
[i
];
7586 cfgtew
.u
.cfgte
= &ioa_cfg
->u
.cfg_table
->dev
[i
];
7589 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7590 if (ipr_is_same_device(res
, &cfgtew
)) {
7591 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7598 if (list_empty(&ioa_cfg
->free_res_q
)) {
7599 dev_err(&ioa_cfg
->pdev
->dev
, "Too many devices attached\n");
7604 res
= list_entry(ioa_cfg
->free_res_q
.next
,
7605 struct ipr_resource_entry
, queue
);
7606 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7607 ipr_init_res_entry(res
, &cfgtew
);
7609 } else if (res
->sdev
&& (ipr_is_vset_device(res
) || ipr_is_scsi_disk(res
)))
7610 res
->sdev
->allow_restart
= 1;
7613 ipr_update_res_entry(res
, &cfgtew
);
7616 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7618 res
->del_from_ml
= 1;
7619 res
->res_handle
= IPR_INVALID_RES_HANDLE
;
7620 list_move_tail(&res
->queue
, &ioa_cfg
->used_res_q
);
7624 list_for_each_entry_safe(res
, temp
, &old_res
, queue
) {
7625 ipr_clear_res_target(res
);
7626 list_move_tail(&res
->queue
, &ioa_cfg
->free_res_q
);
7629 if (ioa_cfg
->dual_raid
&& ipr_dual_ioa_raid
)
7630 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page24
;
7632 ipr_cmd
->job_step
= ipr_ioafp_mode_sense_page28
;
7635 return IPR_RC_JOB_CONTINUE
;
7639 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7640 * @ipr_cmd: ipr command struct
7642 * This function sends a Query IOA Configuration command
7643 * to the adapter to retrieve the IOA configuration table.
7648 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd
*ipr_cmd
)
7650 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7651 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7652 struct ipr_inquiry_page3
*ucode_vpd
= &ioa_cfg
->vpd_cbs
->page3_data
;
7653 struct ipr_inquiry_cap
*cap
= &ioa_cfg
->vpd_cbs
->cap
;
7656 if (cap
->cap
& IPR_CAP_DUAL_IOA_RAID
)
7657 ioa_cfg
->dual_raid
= 1;
7658 dev_info(&ioa_cfg
->pdev
->dev
, "Adapter firmware version: %02X%02X%02X%02X\n",
7659 ucode_vpd
->major_release
, ucode_vpd
->card_type
,
7660 ucode_vpd
->minor_release
[0], ucode_vpd
->minor_release
[1]);
7661 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7662 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7664 ioarcb
->cmd_pkt
.cdb
[0] = IPR_QUERY_IOA_CONFIG
;
7665 ioarcb
->cmd_pkt
.cdb
[6] = (ioa_cfg
->cfg_table_size
>> 16) & 0xff;
7666 ioarcb
->cmd_pkt
.cdb
[7] = (ioa_cfg
->cfg_table_size
>> 8) & 0xff;
7667 ioarcb
->cmd_pkt
.cdb
[8] = ioa_cfg
->cfg_table_size
& 0xff;
7669 ipr_init_ioadl(ipr_cmd
, ioa_cfg
->cfg_table_dma
, ioa_cfg
->cfg_table_size
,
7670 IPR_IOADL_FLAGS_READ_LAST
);
7672 ipr_cmd
->job_step
= ipr_init_res_table
;
7674 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7677 return IPR_RC_JOB_RETURN
;
7680 static int ipr_ioa_service_action_failed(struct ipr_cmnd
*ipr_cmd
)
7682 u32 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
7684 if (ioasc
== IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT
)
7685 return IPR_RC_JOB_CONTINUE
;
7687 return ipr_reset_cmd_failed(ipr_cmd
);
7690 static void ipr_build_ioa_service_action(struct ipr_cmnd
*ipr_cmd
,
7691 __be32 res_handle
, u8 sa_code
)
7693 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7695 ioarcb
->res_handle
= res_handle
;
7696 ioarcb
->cmd_pkt
.cdb
[0] = IPR_IOA_SERVICE_ACTION
;
7697 ioarcb
->cmd_pkt
.cdb
[1] = sa_code
;
7698 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7702 * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7708 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd
*ipr_cmd
)
7710 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7711 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7712 struct ipr_inquiry_pageC4
*pageC4
= &ioa_cfg
->vpd_cbs
->pageC4_data
;
7716 ipr_cmd
->job_step
= ipr_ioafp_query_ioa_cfg
;
7718 if (pageC4
->cache_cap
[0] & IPR_CAP_SYNC_CACHE
) {
7719 ipr_build_ioa_service_action(ipr_cmd
,
7720 cpu_to_be32(IPR_IOA_RES_HANDLE
),
7721 IPR_IOA_SA_CHANGE_CACHE_PARAMS
);
7723 ioarcb
->cmd_pkt
.cdb
[2] = 0x40;
7725 ipr_cmd
->job_step_failed
= ipr_ioa_service_action_failed
;
7726 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
7727 IPR_SET_SUP_DEVICE_TIMEOUT
);
7730 return IPR_RC_JOB_RETURN
;
7734 return IPR_RC_JOB_CONTINUE
;
7738 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7739 * @ipr_cmd: ipr command struct
7741 * This utility function sends an inquiry to the adapter.
7746 static void ipr_ioafp_inquiry(struct ipr_cmnd
*ipr_cmd
, u8 flags
, u8 page
,
7747 dma_addr_t dma_addr
, u8 xfer_len
)
7749 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7752 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
7753 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7755 ioarcb
->cmd_pkt
.cdb
[0] = INQUIRY
;
7756 ioarcb
->cmd_pkt
.cdb
[1] = flags
;
7757 ioarcb
->cmd_pkt
.cdb
[2] = page
;
7758 ioarcb
->cmd_pkt
.cdb
[4] = xfer_len
;
7760 ipr_init_ioadl(ipr_cmd
, dma_addr
, xfer_len
, IPR_IOADL_FLAGS_READ_LAST
);
7762 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, IPR_INTERNAL_TIMEOUT
);
7767 * ipr_inquiry_page_supported - Is the given inquiry page supported
7768 * @page0: inquiry page 0 buffer
7771 * This function determines if the specified inquiry page is supported.
7774 * 1 if page is supported / 0 if not
7776 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0
*page0
, u8 page
)
7780 for (i
= 0; i
< min_t(u8
, page0
->len
, IPR_INQUIRY_PAGE0_ENTRIES
); i
++)
7781 if (page0
->page
[i
] == page
)
7788 * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
7789 * @ipr_cmd: ipr command struct
7791 * This function sends a Page 0xC4 inquiry to the adapter
7792 * to retrieve software VPD information.
7795 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7797 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd
*ipr_cmd
)
7799 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7800 struct ipr_inquiry_page0
*page0
= &ioa_cfg
->vpd_cbs
->page0_data
;
7801 struct ipr_inquiry_pageC4
*pageC4
= &ioa_cfg
->vpd_cbs
->pageC4_data
;
7804 ipr_cmd
->job_step
= ipr_ioafp_set_caching_parameters
;
7805 memset(pageC4
, 0, sizeof(*pageC4
));
7807 if (ipr_inquiry_page_supported(page0
, 0xC4)) {
7808 ipr_ioafp_inquiry(ipr_cmd
, 1, 0xC4,
7809 (ioa_cfg
->vpd_cbs_dma
7810 + offsetof(struct ipr_misc_cbs
,
7812 sizeof(struct ipr_inquiry_pageC4
));
7813 return IPR_RC_JOB_RETURN
;
7817 return IPR_RC_JOB_CONTINUE
;
7821 * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
7822 * @ipr_cmd: ipr command struct
7824 * This function sends a Page 0xD0 inquiry to the adapter
7825 * to retrieve adapter capabilities.
7828 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7830 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd
*ipr_cmd
)
7832 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7833 struct ipr_inquiry_page0
*page0
= &ioa_cfg
->vpd_cbs
->page0_data
;
7834 struct ipr_inquiry_cap
*cap
= &ioa_cfg
->vpd_cbs
->cap
;
7837 ipr_cmd
->job_step
= ipr_ioafp_pageC4_inquiry
;
7838 memset(cap
, 0, sizeof(*cap
));
7840 if (ipr_inquiry_page_supported(page0
, 0xD0)) {
7841 ipr_ioafp_inquiry(ipr_cmd
, 1, 0xD0,
7842 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, cap
),
7843 sizeof(struct ipr_inquiry_cap
));
7844 return IPR_RC_JOB_RETURN
;
7848 return IPR_RC_JOB_CONTINUE
;
7852 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
7853 * @ipr_cmd: ipr command struct
7855 * This function sends a Page 3 inquiry to the adapter
7856 * to retrieve software VPD information.
7859 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7861 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd
*ipr_cmd
)
7863 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7867 ipr_cmd
->job_step
= ipr_ioafp_cap_inquiry
;
7869 ipr_ioafp_inquiry(ipr_cmd
, 1, 3,
7870 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, page3_data
),
7871 sizeof(struct ipr_inquiry_page3
));
7874 return IPR_RC_JOB_RETURN
;
7878 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
7879 * @ipr_cmd: ipr command struct
7881 * This function sends a Page 0 inquiry to the adapter
7882 * to retrieve supported inquiry pages.
7885 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7887 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd
*ipr_cmd
)
7889 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7894 /* Grab the type out of the VPD and store it away */
7895 memcpy(type
, ioa_cfg
->vpd_cbs
->ioa_vpd
.std_inq_data
.vpids
.product_id
, 4);
7897 ioa_cfg
->type
= simple_strtoul((char *)type
, NULL
, 16);
7899 if (ipr_invalid_adapter(ioa_cfg
)) {
7900 dev_err(&ioa_cfg
->pdev
->dev
,
7901 "Adapter not supported in this hardware configuration.\n");
7903 if (!ipr_testmode
) {
7904 ioa_cfg
->reset_retries
+= IPR_NUM_RESET_RELOAD_RETRIES
;
7905 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
7906 list_add_tail(&ipr_cmd
->queue
,
7907 &ioa_cfg
->hrrq
->hrrq_free_q
);
7908 return IPR_RC_JOB_RETURN
;
7912 ipr_cmd
->job_step
= ipr_ioafp_page3_inquiry
;
7914 ipr_ioafp_inquiry(ipr_cmd
, 1, 0,
7915 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, page0_data
),
7916 sizeof(struct ipr_inquiry_page0
));
7919 return IPR_RC_JOB_RETURN
;
7923 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
7924 * @ipr_cmd: ipr command struct
7926 * This function sends a standard inquiry to the adapter.
7931 static int ipr_ioafp_std_inquiry(struct ipr_cmnd
*ipr_cmd
)
7933 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7936 ipr_cmd
->job_step
= ipr_ioafp_page0_inquiry
;
7938 ipr_ioafp_inquiry(ipr_cmd
, 0, 0,
7939 ioa_cfg
->vpd_cbs_dma
+ offsetof(struct ipr_misc_cbs
, ioa_vpd
),
7940 sizeof(struct ipr_ioa_vpd
));
7943 return IPR_RC_JOB_RETURN
;
7947 * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
7948 * @ipr_cmd: ipr command struct
7950 * This function send an Identify Host Request Response Queue
7951 * command to establish the HRRQ with the adapter.
7956 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd
*ipr_cmd
)
7958 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
7959 struct ipr_ioarcb
*ioarcb
= &ipr_cmd
->ioarcb
;
7960 struct ipr_hrr_queue
*hrrq
;
7963 ipr_cmd
->job_step
= ipr_ioafp_std_inquiry
;
7964 dev_info(&ioa_cfg
->pdev
->dev
, "Starting IOA initialization sequence.\n");
7966 if (ioa_cfg
->identify_hrrq_index
< ioa_cfg
->hrrq_num
) {
7967 hrrq
= &ioa_cfg
->hrrq
[ioa_cfg
->identify_hrrq_index
];
7969 ioarcb
->cmd_pkt
.cdb
[0] = IPR_ID_HOST_RR_Q
;
7970 ioarcb
->res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
7972 ioarcb
->cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
7974 ioarcb
->cmd_pkt
.cdb
[1] = 0x1;
7976 if (ioa_cfg
->nvectors
== 1)
7977 ioarcb
->cmd_pkt
.cdb
[1] &= ~IPR_ID_HRRQ_SELE_ENABLE
;
7979 ioarcb
->cmd_pkt
.cdb
[1] |= IPR_ID_HRRQ_SELE_ENABLE
;
7981 ioarcb
->cmd_pkt
.cdb
[2] =
7982 ((u64
) hrrq
->host_rrq_dma
>> 24) & 0xff;
7983 ioarcb
->cmd_pkt
.cdb
[3] =
7984 ((u64
) hrrq
->host_rrq_dma
>> 16) & 0xff;
7985 ioarcb
->cmd_pkt
.cdb
[4] =
7986 ((u64
) hrrq
->host_rrq_dma
>> 8) & 0xff;
7987 ioarcb
->cmd_pkt
.cdb
[5] =
7988 ((u64
) hrrq
->host_rrq_dma
) & 0xff;
7989 ioarcb
->cmd_pkt
.cdb
[7] =
7990 ((sizeof(u32
) * hrrq
->size
) >> 8) & 0xff;
7991 ioarcb
->cmd_pkt
.cdb
[8] =
7992 (sizeof(u32
) * hrrq
->size
) & 0xff;
7994 if (ioarcb
->cmd_pkt
.cdb
[1] & IPR_ID_HRRQ_SELE_ENABLE
)
7995 ioarcb
->cmd_pkt
.cdb
[9] =
7996 ioa_cfg
->identify_hrrq_index
;
7998 if (ioa_cfg
->sis64
) {
7999 ioarcb
->cmd_pkt
.cdb
[10] =
8000 ((u64
) hrrq
->host_rrq_dma
>> 56) & 0xff;
8001 ioarcb
->cmd_pkt
.cdb
[11] =
8002 ((u64
) hrrq
->host_rrq_dma
>> 48) & 0xff;
8003 ioarcb
->cmd_pkt
.cdb
[12] =
8004 ((u64
) hrrq
->host_rrq_dma
>> 40) & 0xff;
8005 ioarcb
->cmd_pkt
.cdb
[13] =
8006 ((u64
) hrrq
->host_rrq_dma
>> 32) & 0xff;
8009 if (ioarcb
->cmd_pkt
.cdb
[1] & IPR_ID_HRRQ_SELE_ENABLE
)
8010 ioarcb
->cmd_pkt
.cdb
[14] =
8011 ioa_cfg
->identify_hrrq_index
;
8013 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
8014 IPR_INTERNAL_TIMEOUT
);
8016 if (++ioa_cfg
->identify_hrrq_index
< ioa_cfg
->hrrq_num
)
8017 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8020 return IPR_RC_JOB_RETURN
;
8024 return IPR_RC_JOB_CONTINUE
;
8028 * ipr_reset_timer_done - Adapter reset timer function
8029 * @ipr_cmd: ipr command struct
8031 * Description: This function is used in adapter reset processing
8032 * for timing events. If the reset_cmd pointer in the IOA
8033 * config struct is not this adapter's we are doing nested
8034 * resets and fail_all_ops will take care of freeing the
8040 static void ipr_reset_timer_done(struct ipr_cmnd
*ipr_cmd
)
8042 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8043 unsigned long lock_flags
= 0;
8045 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
8047 if (ioa_cfg
->reset_cmd
== ipr_cmd
) {
8048 list_del(&ipr_cmd
->queue
);
8049 ipr_cmd
->done(ipr_cmd
);
8052 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
8056 * ipr_reset_start_timer - Start a timer for adapter reset job
8057 * @ipr_cmd: ipr command struct
8058 * @timeout: timeout value
8060 * Description: This function is used in adapter reset processing
8061 * for timing events. If the reset_cmd pointer in the IOA
8062 * config struct is not this adapter's we are doing nested
8063 * resets and fail_all_ops will take care of freeing the
8069 static void ipr_reset_start_timer(struct ipr_cmnd
*ipr_cmd
,
8070 unsigned long timeout
)
8074 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8075 ipr_cmd
->done
= ipr_reset_ioa_job
;
8077 ipr_cmd
->timer
.data
= (unsigned long) ipr_cmd
;
8078 ipr_cmd
->timer
.expires
= jiffies
+ timeout
;
8079 ipr_cmd
->timer
.function
= (void (*)(unsigned long))ipr_reset_timer_done
;
8080 add_timer(&ipr_cmd
->timer
);
8084 * ipr_init_ioa_mem - Initialize ioa_cfg control block
8085 * @ioa_cfg: ioa cfg struct
8090 static void ipr_init_ioa_mem(struct ipr_ioa_cfg
*ioa_cfg
)
8092 struct ipr_hrr_queue
*hrrq
;
8094 for_each_hrrq(hrrq
, ioa_cfg
) {
8095 spin_lock(&hrrq
->_lock
);
8096 memset(hrrq
->host_rrq
, 0, sizeof(u32
) * hrrq
->size
);
8098 /* Initialize Host RRQ pointers */
8099 hrrq
->hrrq_start
= hrrq
->host_rrq
;
8100 hrrq
->hrrq_end
= &hrrq
->host_rrq
[hrrq
->size
- 1];
8101 hrrq
->hrrq_curr
= hrrq
->hrrq_start
;
8102 hrrq
->toggle_bit
= 1;
8103 spin_unlock(&hrrq
->_lock
);
8107 ioa_cfg
->identify_hrrq_index
= 0;
8108 if (ioa_cfg
->hrrq_num
== 1)
8109 atomic_set(&ioa_cfg
->hrrq_index
, 0);
8111 atomic_set(&ioa_cfg
->hrrq_index
, 1);
8113 /* Zero out config table */
8114 memset(ioa_cfg
->u
.cfg_table
, 0, ioa_cfg
->cfg_table_size
);
8118 * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8119 * @ipr_cmd: ipr command struct
8122 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8124 static int ipr_reset_next_stage(struct ipr_cmnd
*ipr_cmd
)
8126 unsigned long stage
, stage_time
;
8128 volatile u32 int_reg
;
8129 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8132 feedback
= readl(ioa_cfg
->regs
.init_feedback_reg
);
8133 stage
= feedback
& IPR_IPL_INIT_STAGE_MASK
;
8134 stage_time
= feedback
& IPR_IPL_INIT_STAGE_TIME_MASK
;
8136 ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage
, stage_time
);
8138 /* sanity check the stage_time value */
8139 if (stage_time
== 0)
8140 stage_time
= IPR_IPL_INIT_DEFAULT_STAGE_TIME
;
8141 else if (stage_time
< IPR_IPL_INIT_MIN_STAGE_TIME
)
8142 stage_time
= IPR_IPL_INIT_MIN_STAGE_TIME
;
8143 else if (stage_time
> IPR_LONG_OPERATIONAL_TIMEOUT
)
8144 stage_time
= IPR_LONG_OPERATIONAL_TIMEOUT
;
8146 if (stage
== IPR_IPL_INIT_STAGE_UNKNOWN
) {
8147 writel(IPR_PCII_IPL_STAGE_CHANGE
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
8148 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8149 stage_time
= ioa_cfg
->transop_timeout
;
8150 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8151 } else if (stage
== IPR_IPL_INIT_STAGE_TRANSOP
) {
8152 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
8153 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
8154 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8155 maskval
= IPR_PCII_IPL_STAGE_CHANGE
;
8156 maskval
= (maskval
<< 32) | IPR_PCII_IOA_TRANS_TO_OPER
;
8157 writeq(maskval
, ioa_cfg
->regs
.set_interrupt_mask_reg
);
8158 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8159 return IPR_RC_JOB_CONTINUE
;
8163 ipr_cmd
->timer
.data
= (unsigned long) ipr_cmd
;
8164 ipr_cmd
->timer
.expires
= jiffies
+ stage_time
* HZ
;
8165 ipr_cmd
->timer
.function
= (void (*)(unsigned long))ipr_oper_timeout
;
8166 ipr_cmd
->done
= ipr_reset_ioa_job
;
8167 add_timer(&ipr_cmd
->timer
);
8169 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8171 return IPR_RC_JOB_RETURN
;
8175 * ipr_reset_enable_ioa - Enable the IOA following a reset.
8176 * @ipr_cmd: ipr command struct
8178 * This function reinitializes some control blocks and
8179 * enables destructive diagnostics on the adapter.
8184 static int ipr_reset_enable_ioa(struct ipr_cmnd
*ipr_cmd
)
8186 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8187 volatile u32 int_reg
;
8188 volatile u64 maskval
;
8192 ipr_cmd
->job_step
= ipr_ioafp_identify_hrrq
;
8193 ipr_init_ioa_mem(ioa_cfg
);
8195 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
8196 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
8197 ioa_cfg
->hrrq
[i
].allow_interrupts
= 1;
8198 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
8201 if (ioa_cfg
->sis64
) {
8202 /* Set the adapter to the correct endian mode. */
8203 writel(IPR_ENDIAN_SWAP_KEY
, ioa_cfg
->regs
.endian_swap_reg
);
8204 int_reg
= readl(ioa_cfg
->regs
.endian_swap_reg
);
8207 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
8209 if (int_reg
& IPR_PCII_IOA_TRANS_TO_OPER
) {
8210 writel((IPR_PCII_ERROR_INTERRUPTS
| IPR_PCII_HRRQ_UPDATED
),
8211 ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
8212 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8213 return IPR_RC_JOB_CONTINUE
;
8216 /* Enable destructive diagnostics on IOA */
8217 writel(ioa_cfg
->doorbell
, ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8219 if (ioa_cfg
->sis64
) {
8220 maskval
= IPR_PCII_IPL_STAGE_CHANGE
;
8221 maskval
= (maskval
<< 32) | IPR_PCII_OPER_INTERRUPTS
;
8222 writeq(maskval
, ioa_cfg
->regs
.clr_interrupt_mask_reg
);
8224 writel(IPR_PCII_OPER_INTERRUPTS
, ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
8226 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
8228 dev_info(&ioa_cfg
->pdev
->dev
, "Initializing IOA.\n");
8230 if (ioa_cfg
->sis64
) {
8231 ipr_cmd
->job_step
= ipr_reset_next_stage
;
8232 return IPR_RC_JOB_CONTINUE
;
8235 ipr_cmd
->timer
.data
= (unsigned long) ipr_cmd
;
8236 ipr_cmd
->timer
.expires
= jiffies
+ (ioa_cfg
->transop_timeout
* HZ
);
8237 ipr_cmd
->timer
.function
= (void (*)(unsigned long))ipr_oper_timeout
;
8238 ipr_cmd
->done
= ipr_reset_ioa_job
;
8239 add_timer(&ipr_cmd
->timer
);
8240 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
8243 return IPR_RC_JOB_RETURN
;
8247 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8248 * @ipr_cmd: ipr command struct
8250 * This function is invoked when an adapter dump has run out
8251 * of processing time.
8254 * IPR_RC_JOB_CONTINUE
8256 static int ipr_reset_wait_for_dump(struct ipr_cmnd
*ipr_cmd
)
8258 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8260 if (ioa_cfg
->sdt_state
== GET_DUMP
)
8261 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
8262 else if (ioa_cfg
->sdt_state
== READ_DUMP
)
8263 ioa_cfg
->sdt_state
= ABORT_DUMP
;
8265 ioa_cfg
->dump_timeout
= 1;
8266 ipr_cmd
->job_step
= ipr_reset_alert
;
8268 return IPR_RC_JOB_CONTINUE
;
8272 * ipr_unit_check_no_data - Log a unit check/no data error log
8273 * @ioa_cfg: ioa config struct
8275 * Logs an error indicating the adapter unit checked, but for some
8276 * reason, we were unable to fetch the unit check buffer.
8281 static void ipr_unit_check_no_data(struct ipr_ioa_cfg
*ioa_cfg
)
8283 ioa_cfg
->errors_logged
++;
8284 dev_err(&ioa_cfg
->pdev
->dev
, "IOA unit check with no data\n");
8288 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8289 * @ioa_cfg: ioa config struct
8291 * Fetches the unit check buffer from the adapter by clocking the data
8292 * through the mailbox register.
8297 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg
*ioa_cfg
)
8299 unsigned long mailbox
;
8300 struct ipr_hostrcb
*hostrcb
;
8301 struct ipr_uc_sdt sdt
;
8305 mailbox
= readl(ioa_cfg
->ioa_mailbox
);
8307 if (!ioa_cfg
->sis64
&& !ipr_sdt_is_fmt2(mailbox
)) {
8308 ipr_unit_check_no_data(ioa_cfg
);
8312 memset(&sdt
, 0, sizeof(struct ipr_uc_sdt
));
8313 rc
= ipr_get_ldump_data_section(ioa_cfg
, mailbox
, (__be32
*) &sdt
,
8314 (sizeof(struct ipr_uc_sdt
)) / sizeof(__be32
));
8316 if (rc
|| !(sdt
.entry
[0].flags
& IPR_SDT_VALID_ENTRY
) ||
8317 ((be32_to_cpu(sdt
.hdr
.state
) != IPR_FMT3_SDT_READY_TO_USE
) &&
8318 (be32_to_cpu(sdt
.hdr
.state
) != IPR_FMT2_SDT_READY_TO_USE
))) {
8319 ipr_unit_check_no_data(ioa_cfg
);
8323 /* Find length of the first sdt entry (UC buffer) */
8324 if (be32_to_cpu(sdt
.hdr
.state
) == IPR_FMT3_SDT_READY_TO_USE
)
8325 length
= be32_to_cpu(sdt
.entry
[0].end_token
);
8327 length
= (be32_to_cpu(sdt
.entry
[0].end_token
) -
8328 be32_to_cpu(sdt
.entry
[0].start_token
)) &
8329 IPR_FMT2_MBX_ADDR_MASK
;
8331 hostrcb
= list_entry(ioa_cfg
->hostrcb_free_q
.next
,
8332 struct ipr_hostrcb
, queue
);
8333 list_del(&hostrcb
->queue
);
8334 memset(&hostrcb
->hcam
, 0, sizeof(hostrcb
->hcam
));
8336 rc
= ipr_get_ldump_data_section(ioa_cfg
,
8337 be32_to_cpu(sdt
.entry
[0].start_token
),
8338 (__be32
*)&hostrcb
->hcam
,
8339 min(length
, (int)sizeof(hostrcb
->hcam
)) / sizeof(__be32
));
8342 ipr_handle_log_data(ioa_cfg
, hostrcb
);
8343 ioasc
= be32_to_cpu(hostrcb
->hcam
.u
.error
.fd_ioasc
);
8344 if (ioasc
== IPR_IOASC_NR_IOA_RESET_REQUIRED
&&
8345 ioa_cfg
->sdt_state
== GET_DUMP
)
8346 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
8348 ipr_unit_check_no_data(ioa_cfg
);
8350 list_add_tail(&hostrcb
->queue
, &ioa_cfg
->hostrcb_free_q
);
8354 * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8355 * @ipr_cmd: ipr command struct
8357 * Description: This function will call to get the unit check buffer.
8362 static int ipr_reset_get_unit_check_job(struct ipr_cmnd
*ipr_cmd
)
8364 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8367 ioa_cfg
->ioa_unit_checked
= 0;
8368 ipr_get_unit_check_buffer(ioa_cfg
);
8369 ipr_cmd
->job_step
= ipr_reset_alert
;
8370 ipr_reset_start_timer(ipr_cmd
, 0);
8373 return IPR_RC_JOB_RETURN
;
8376 static int ipr_dump_mailbox_wait(struct ipr_cmnd
*ipr_cmd
)
8378 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8382 if (ioa_cfg
->sdt_state
!= GET_DUMP
)
8383 return IPR_RC_JOB_RETURN
;
8385 if (!ioa_cfg
->sis64
|| !ipr_cmd
->u
.time_left
||
8386 (readl(ioa_cfg
->regs
.sense_interrupt_reg
) &
8387 IPR_PCII_MAILBOX_STABLE
)) {
8389 if (!ipr_cmd
->u
.time_left
)
8390 dev_err(&ioa_cfg
->pdev
->dev
,
8391 "Timed out waiting for Mailbox register.\n");
8393 ioa_cfg
->sdt_state
= READ_DUMP
;
8394 ioa_cfg
->dump_timeout
= 0;
8396 ipr_reset_start_timer(ipr_cmd
, IPR_SIS64_DUMP_TIMEOUT
);
8398 ipr_reset_start_timer(ipr_cmd
, IPR_SIS32_DUMP_TIMEOUT
);
8399 ipr_cmd
->job_step
= ipr_reset_wait_for_dump
;
8400 schedule_work(&ioa_cfg
->work_q
);
8403 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8404 ipr_reset_start_timer(ipr_cmd
,
8405 IPR_CHECK_FOR_RESET_TIMEOUT
);
8409 return IPR_RC_JOB_RETURN
;
8413 * ipr_reset_restore_cfg_space - Restore PCI config space.
8414 * @ipr_cmd: ipr command struct
8416 * Description: This function restores the saved PCI config space of
8417 * the adapter, fails all outstanding ops back to the callers, and
8418 * fetches the dump/unit check if applicable to this reset.
8421 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8423 static int ipr_reset_restore_cfg_space(struct ipr_cmnd
*ipr_cmd
)
8425 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8429 ioa_cfg
->pdev
->state_saved
= true;
8430 pci_restore_state(ioa_cfg
->pdev
);
8432 if (ipr_set_pcix_cmd_reg(ioa_cfg
)) {
8433 ipr_cmd
->s
.ioasa
.hdr
.ioasc
= cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR
);
8434 return IPR_RC_JOB_CONTINUE
;
8437 ipr_fail_all_ops(ioa_cfg
);
8439 if (ioa_cfg
->sis64
) {
8440 /* Set the adapter to the correct endian mode. */
8441 writel(IPR_ENDIAN_SWAP_KEY
, ioa_cfg
->regs
.endian_swap_reg
);
8442 int_reg
= readl(ioa_cfg
->regs
.endian_swap_reg
);
8445 if (ioa_cfg
->ioa_unit_checked
) {
8446 if (ioa_cfg
->sis64
) {
8447 ipr_cmd
->job_step
= ipr_reset_get_unit_check_job
;
8448 ipr_reset_start_timer(ipr_cmd
, IPR_DUMP_DELAY_TIMEOUT
);
8449 return IPR_RC_JOB_RETURN
;
8451 ioa_cfg
->ioa_unit_checked
= 0;
8452 ipr_get_unit_check_buffer(ioa_cfg
);
8453 ipr_cmd
->job_step
= ipr_reset_alert
;
8454 ipr_reset_start_timer(ipr_cmd
, 0);
8455 return IPR_RC_JOB_RETURN
;
8459 if (ioa_cfg
->in_ioa_bringdown
) {
8460 ipr_cmd
->job_step
= ipr_ioa_bringdown_done
;
8461 } else if (ioa_cfg
->sdt_state
== GET_DUMP
) {
8462 ipr_cmd
->job_step
= ipr_dump_mailbox_wait
;
8463 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_MAILBOX
;
8465 ipr_cmd
->job_step
= ipr_reset_enable_ioa
;
8469 return IPR_RC_JOB_CONTINUE
;
8473 * ipr_reset_bist_done - BIST has completed on the adapter.
8474 * @ipr_cmd: ipr command struct
8476 * Description: Unblock config space and resume the reset process.
8479 * IPR_RC_JOB_CONTINUE
8481 static int ipr_reset_bist_done(struct ipr_cmnd
*ipr_cmd
)
8483 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8486 if (ioa_cfg
->cfg_locked
)
8487 pci_cfg_access_unlock(ioa_cfg
->pdev
);
8488 ioa_cfg
->cfg_locked
= 0;
8489 ipr_cmd
->job_step
= ipr_reset_restore_cfg_space
;
8491 return IPR_RC_JOB_CONTINUE
;
8495 * ipr_reset_start_bist - Run BIST on the adapter.
8496 * @ipr_cmd: ipr command struct
8498 * Description: This function runs BIST on the adapter, then delays 2 seconds.
8501 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8503 static int ipr_reset_start_bist(struct ipr_cmnd
*ipr_cmd
)
8505 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8506 int rc
= PCIBIOS_SUCCESSFUL
;
8509 if (ioa_cfg
->ipr_chip
->bist_method
== IPR_MMIO
)
8510 writel(IPR_UPROCI_SIS64_START_BIST
,
8511 ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8513 rc
= pci_write_config_byte(ioa_cfg
->pdev
, PCI_BIST
, PCI_BIST_START
);
8515 if (rc
== PCIBIOS_SUCCESSFUL
) {
8516 ipr_cmd
->job_step
= ipr_reset_bist_done
;
8517 ipr_reset_start_timer(ipr_cmd
, IPR_WAIT_FOR_BIST_TIMEOUT
);
8518 rc
= IPR_RC_JOB_RETURN
;
8520 if (ioa_cfg
->cfg_locked
)
8521 pci_cfg_access_unlock(ipr_cmd
->ioa_cfg
->pdev
);
8522 ioa_cfg
->cfg_locked
= 0;
8523 ipr_cmd
->s
.ioasa
.hdr
.ioasc
= cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR
);
8524 rc
= IPR_RC_JOB_CONTINUE
;
8532 * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8533 * @ipr_cmd: ipr command struct
8535 * Description: This clears PCI reset to the adapter and delays two seconds.
8540 static int ipr_reset_slot_reset_done(struct ipr_cmnd
*ipr_cmd
)
8543 ipr_cmd
->job_step
= ipr_reset_bist_done
;
8544 ipr_reset_start_timer(ipr_cmd
, IPR_WAIT_FOR_BIST_TIMEOUT
);
8546 return IPR_RC_JOB_RETURN
;
8550 * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8551 * @work: work struct
8553 * Description: This pulses warm reset to a slot.
8556 static void ipr_reset_reset_work(struct work_struct
*work
)
8558 struct ipr_cmnd
*ipr_cmd
= container_of(work
, struct ipr_cmnd
, work
);
8559 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8560 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
8561 unsigned long lock_flags
= 0;
8564 pci_set_pcie_reset_state(pdev
, pcie_warm_reset
);
8565 msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT
));
8566 pci_set_pcie_reset_state(pdev
, pcie_deassert_reset
);
8568 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
8569 if (ioa_cfg
->reset_cmd
== ipr_cmd
)
8570 ipr_reset_ioa_job(ipr_cmd
);
8571 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
8576 * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8577 * @ipr_cmd: ipr command struct
8579 * Description: This asserts PCI reset to the adapter.
8584 static int ipr_reset_slot_reset(struct ipr_cmnd
*ipr_cmd
)
8586 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8589 INIT_WORK(&ipr_cmd
->work
, ipr_reset_reset_work
);
8590 queue_work(ioa_cfg
->reset_work_q
, &ipr_cmd
->work
);
8591 ipr_cmd
->job_step
= ipr_reset_slot_reset_done
;
8593 return IPR_RC_JOB_RETURN
;
8597 * ipr_reset_block_config_access_wait - Wait for permission to block config access
8598 * @ipr_cmd: ipr command struct
8600 * Description: This attempts to block config access to the IOA.
8603 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8605 static int ipr_reset_block_config_access_wait(struct ipr_cmnd
*ipr_cmd
)
8607 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8608 int rc
= IPR_RC_JOB_CONTINUE
;
8610 if (pci_cfg_access_trylock(ioa_cfg
->pdev
)) {
8611 ioa_cfg
->cfg_locked
= 1;
8612 ipr_cmd
->job_step
= ioa_cfg
->reset
;
8614 if (ipr_cmd
->u
.time_left
) {
8615 rc
= IPR_RC_JOB_RETURN
;
8616 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8617 ipr_reset_start_timer(ipr_cmd
,
8618 IPR_CHECK_FOR_RESET_TIMEOUT
);
8620 ipr_cmd
->job_step
= ioa_cfg
->reset
;
8621 dev_err(&ioa_cfg
->pdev
->dev
,
8622 "Timed out waiting to lock config access. Resetting anyway.\n");
8630 * ipr_reset_block_config_access - Block config access to the IOA
8631 * @ipr_cmd: ipr command struct
8633 * Description: This attempts to block config access to the IOA
8636 * IPR_RC_JOB_CONTINUE
8638 static int ipr_reset_block_config_access(struct ipr_cmnd
*ipr_cmd
)
8640 ipr_cmd
->ioa_cfg
->cfg_locked
= 0;
8641 ipr_cmd
->job_step
= ipr_reset_block_config_access_wait
;
8642 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_RESET_TIMEOUT
;
8643 return IPR_RC_JOB_CONTINUE
;
8647 * ipr_reset_allowed - Query whether or not IOA can be reset
8648 * @ioa_cfg: ioa config struct
8651 * 0 if reset not allowed / non-zero if reset is allowed
8653 static int ipr_reset_allowed(struct ipr_ioa_cfg
*ioa_cfg
)
8655 volatile u32 temp_reg
;
8657 temp_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
8658 return ((temp_reg
& IPR_PCII_CRITICAL_OPERATION
) == 0);
8662 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8663 * @ipr_cmd: ipr command struct
8665 * Description: This function waits for adapter permission to run BIST,
8666 * then runs BIST. If the adapter does not give permission after a
8667 * reasonable time, we will reset the adapter anyway. The impact of
8668 * resetting the adapter without warning the adapter is the risk of
8669 * losing the persistent error log on the adapter. If the adapter is
8670 * reset while it is writing to the flash on the adapter, the flash
8671 * segment will have bad ECC and be zeroed.
8674 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8676 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd
*ipr_cmd
)
8678 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8679 int rc
= IPR_RC_JOB_RETURN
;
8681 if (!ipr_reset_allowed(ioa_cfg
) && ipr_cmd
->u
.time_left
) {
8682 ipr_cmd
->u
.time_left
-= IPR_CHECK_FOR_RESET_TIMEOUT
;
8683 ipr_reset_start_timer(ipr_cmd
, IPR_CHECK_FOR_RESET_TIMEOUT
);
8685 ipr_cmd
->job_step
= ipr_reset_block_config_access
;
8686 rc
= IPR_RC_JOB_CONTINUE
;
8693 * ipr_reset_alert - Alert the adapter of a pending reset
8694 * @ipr_cmd: ipr command struct
8696 * Description: This function alerts the adapter that it will be reset.
8697 * If memory space is not currently enabled, proceed directly
8698 * to running BIST on the adapter. The timer must always be started
8699 * so we guarantee we do not run BIST from ipr_isr.
8704 static int ipr_reset_alert(struct ipr_cmnd
*ipr_cmd
)
8706 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8711 rc
= pci_read_config_word(ioa_cfg
->pdev
, PCI_COMMAND
, &cmd_reg
);
8713 if ((rc
== PCIBIOS_SUCCESSFUL
) && (cmd_reg
& PCI_COMMAND_MEMORY
)) {
8714 ipr_mask_and_clear_interrupts(ioa_cfg
, ~0);
8715 writel(IPR_UPROCI_RESET_ALERT
, ioa_cfg
->regs
.set_uproc_interrupt_reg32
);
8716 ipr_cmd
->job_step
= ipr_reset_wait_to_start_bist
;
8718 ipr_cmd
->job_step
= ipr_reset_block_config_access
;
8721 ipr_cmd
->u
.time_left
= IPR_WAIT_FOR_RESET_TIMEOUT
;
8722 ipr_reset_start_timer(ipr_cmd
, IPR_CHECK_FOR_RESET_TIMEOUT
);
8725 return IPR_RC_JOB_RETURN
;
8729 * ipr_reset_quiesce_done - Complete IOA disconnect
8730 * @ipr_cmd: ipr command struct
8732 * Description: Freeze the adapter to complete quiesce processing
8735 * IPR_RC_JOB_CONTINUE
8737 static int ipr_reset_quiesce_done(struct ipr_cmnd
*ipr_cmd
)
8739 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8742 ipr_cmd
->job_step
= ipr_ioa_bringdown_done
;
8743 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
8745 return IPR_RC_JOB_CONTINUE
;
8749 * ipr_reset_cancel_hcam_done - Check for outstanding commands
8750 * @ipr_cmd: ipr command struct
8752 * Description: Ensure nothing is outstanding to the IOA and
8753 * proceed with IOA disconnect. Otherwise reset the IOA.
8756 * IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
8758 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd
*ipr_cmd
)
8760 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8761 struct ipr_cmnd
*loop_cmd
;
8762 struct ipr_hrr_queue
*hrrq
;
8763 int rc
= IPR_RC_JOB_CONTINUE
;
8767 ipr_cmd
->job_step
= ipr_reset_quiesce_done
;
8769 for_each_hrrq(hrrq
, ioa_cfg
) {
8770 spin_lock(&hrrq
->_lock
);
8771 list_for_each_entry(loop_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
8773 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
8774 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
8775 rc
= IPR_RC_JOB_RETURN
;
8778 spin_unlock(&hrrq
->_lock
);
8789 * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
8790 * @ipr_cmd: ipr command struct
8792 * Description: Cancel any oustanding HCAMs to the IOA.
8795 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8797 static int ipr_reset_cancel_hcam(struct ipr_cmnd
*ipr_cmd
)
8799 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8800 int rc
= IPR_RC_JOB_CONTINUE
;
8801 struct ipr_cmd_pkt
*cmd_pkt
;
8802 struct ipr_cmnd
*hcam_cmd
;
8803 struct ipr_hrr_queue
*hrrq
= &ioa_cfg
->hrrq
[IPR_INIT_HRRQ
];
8806 ipr_cmd
->job_step
= ipr_reset_cancel_hcam_done
;
8808 if (!hrrq
->ioa_is_dead
) {
8809 if (!list_empty(&ioa_cfg
->hostrcb_pending_q
)) {
8810 list_for_each_entry(hcam_cmd
, &hrrq
->hrrq_pending_q
, queue
) {
8811 if (hcam_cmd
->ioarcb
.cmd_pkt
.cdb
[0] != IPR_HOST_CONTROLLED_ASYNC
)
8814 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
8815 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
8816 cmd_pkt
= &ipr_cmd
->ioarcb
.cmd_pkt
;
8817 cmd_pkt
->request_type
= IPR_RQTYPE_IOACMD
;
8818 cmd_pkt
->cdb
[0] = IPR_CANCEL_REQUEST
;
8819 cmd_pkt
->cdb
[1] = IPR_CANCEL_64BIT_IOARCB
;
8820 cmd_pkt
->cdb
[10] = ((u64
) hcam_cmd
->dma_addr
>> 56) & 0xff;
8821 cmd_pkt
->cdb
[11] = ((u64
) hcam_cmd
->dma_addr
>> 48) & 0xff;
8822 cmd_pkt
->cdb
[12] = ((u64
) hcam_cmd
->dma_addr
>> 40) & 0xff;
8823 cmd_pkt
->cdb
[13] = ((u64
) hcam_cmd
->dma_addr
>> 32) & 0xff;
8824 cmd_pkt
->cdb
[2] = ((u64
) hcam_cmd
->dma_addr
>> 24) & 0xff;
8825 cmd_pkt
->cdb
[3] = ((u64
) hcam_cmd
->dma_addr
>> 16) & 0xff;
8826 cmd_pkt
->cdb
[4] = ((u64
) hcam_cmd
->dma_addr
>> 8) & 0xff;
8827 cmd_pkt
->cdb
[5] = ((u64
) hcam_cmd
->dma_addr
) & 0xff;
8829 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
8830 IPR_CANCEL_TIMEOUT
);
8832 rc
= IPR_RC_JOB_RETURN
;
8833 ipr_cmd
->job_step
= ipr_reset_cancel_hcam
;
8838 ipr_cmd
->job_step
= ipr_reset_alert
;
8845 * ipr_reset_ucode_download_done - Microcode download completion
8846 * @ipr_cmd: ipr command struct
8848 * Description: This function unmaps the microcode download buffer.
8851 * IPR_RC_JOB_CONTINUE
8853 static int ipr_reset_ucode_download_done(struct ipr_cmnd
*ipr_cmd
)
8855 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8856 struct ipr_sglist
*sglist
= ioa_cfg
->ucode_sglist
;
8858 dma_unmap_sg(&ioa_cfg
->pdev
->dev
, sglist
->scatterlist
,
8859 sglist
->num_sg
, DMA_TO_DEVICE
);
8861 ipr_cmd
->job_step
= ipr_reset_alert
;
8862 return IPR_RC_JOB_CONTINUE
;
8866 * ipr_reset_ucode_download - Download microcode to the adapter
8867 * @ipr_cmd: ipr command struct
8869 * Description: This function checks to see if it there is microcode
8870 * to download to the adapter. If there is, a download is performed.
8873 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8875 static int ipr_reset_ucode_download(struct ipr_cmnd
*ipr_cmd
)
8877 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8878 struct ipr_sglist
*sglist
= ioa_cfg
->ucode_sglist
;
8881 ipr_cmd
->job_step
= ipr_reset_alert
;
8884 return IPR_RC_JOB_CONTINUE
;
8886 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
8887 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_SCSICDB
;
8888 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = WRITE_BUFFER
;
8889 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE
;
8890 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[6] = (sglist
->buffer_len
& 0xff0000) >> 16;
8891 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[7] = (sglist
->buffer_len
& 0x00ff00) >> 8;
8892 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[8] = sglist
->buffer_len
& 0x0000ff;
8895 ipr_build_ucode_ioadl64(ipr_cmd
, sglist
);
8897 ipr_build_ucode_ioadl(ipr_cmd
, sglist
);
8898 ipr_cmd
->job_step
= ipr_reset_ucode_download_done
;
8900 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
,
8901 IPR_WRITE_BUFFER_TIMEOUT
);
8904 return IPR_RC_JOB_RETURN
;
8908 * ipr_reset_shutdown_ioa - Shutdown the adapter
8909 * @ipr_cmd: ipr command struct
8911 * Description: This function issues an adapter shutdown of the
8912 * specified type to the specified adapter as part of the
8913 * adapter reset job.
8916 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8918 static int ipr_reset_shutdown_ioa(struct ipr_cmnd
*ipr_cmd
)
8920 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8921 enum ipr_shutdown_type shutdown_type
= ipr_cmd
->u
.shutdown_type
;
8922 unsigned long timeout
;
8923 int rc
= IPR_RC_JOB_CONTINUE
;
8926 if (shutdown_type
== IPR_SHUTDOWN_QUIESCE
)
8927 ipr_cmd
->job_step
= ipr_reset_cancel_hcam
;
8928 else if (shutdown_type
!= IPR_SHUTDOWN_NONE
&&
8929 !ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
) {
8930 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
8931 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
8932 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = IPR_IOA_SHUTDOWN
;
8933 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = shutdown_type
;
8935 if (shutdown_type
== IPR_SHUTDOWN_NORMAL
)
8936 timeout
= IPR_SHUTDOWN_TIMEOUT
;
8937 else if (shutdown_type
== IPR_SHUTDOWN_PREPARE_FOR_NORMAL
)
8938 timeout
= IPR_INTERNAL_TIMEOUT
;
8939 else if (ioa_cfg
->dual_raid
&& ipr_dual_ioa_raid
)
8940 timeout
= IPR_DUAL_IOA_ABBR_SHUTDOWN_TO
;
8942 timeout
= IPR_ABBREV_SHUTDOWN_TIMEOUT
;
8944 ipr_do_req(ipr_cmd
, ipr_reset_ioa_job
, ipr_timeout
, timeout
);
8946 rc
= IPR_RC_JOB_RETURN
;
8947 ipr_cmd
->job_step
= ipr_reset_ucode_download
;
8949 ipr_cmd
->job_step
= ipr_reset_alert
;
8956 * ipr_reset_ioa_job - Adapter reset job
8957 * @ipr_cmd: ipr command struct
8959 * Description: This function is the job router for the adapter reset job.
8964 static void ipr_reset_ioa_job(struct ipr_cmnd
*ipr_cmd
)
8967 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
8970 ioasc
= be32_to_cpu(ipr_cmd
->s
.ioasa
.hdr
.ioasc
);
8972 if (ioa_cfg
->reset_cmd
!= ipr_cmd
) {
8974 * We are doing nested adapter resets and this is
8975 * not the current reset job.
8977 list_add_tail(&ipr_cmd
->queue
,
8978 &ipr_cmd
->hrrq
->hrrq_free_q
);
8982 if (IPR_IOASC_SENSE_KEY(ioasc
)) {
8983 rc
= ipr_cmd
->job_step_failed(ipr_cmd
);
8984 if (rc
== IPR_RC_JOB_RETURN
)
8988 ipr_reinit_ipr_cmnd(ipr_cmd
);
8989 ipr_cmd
->job_step_failed
= ipr_reset_cmd_failed
;
8990 rc
= ipr_cmd
->job_step(ipr_cmd
);
8991 } while (rc
== IPR_RC_JOB_CONTINUE
);
8995 * _ipr_initiate_ioa_reset - Initiate an adapter reset
8996 * @ioa_cfg: ioa config struct
8997 * @job_step: first job step of reset job
8998 * @shutdown_type: shutdown type
9000 * Description: This function will initiate the reset of the given adapter
9001 * starting at the selected job step.
9002 * If the caller needs to wait on the completion of the reset,
9003 * the caller must sleep on the reset_wait_q.
9008 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg
*ioa_cfg
,
9009 int (*job_step
) (struct ipr_cmnd
*),
9010 enum ipr_shutdown_type shutdown_type
)
9012 struct ipr_cmnd
*ipr_cmd
;
9015 ioa_cfg
->in_reset_reload
= 1;
9016 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9017 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9018 ioa_cfg
->hrrq
[i
].allow_cmds
= 0;
9019 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9022 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
)
9023 scsi_block_requests(ioa_cfg
->host
);
9025 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
9026 ioa_cfg
->reset_cmd
= ipr_cmd
;
9027 ipr_cmd
->job_step
= job_step
;
9028 ipr_cmd
->u
.shutdown_type
= shutdown_type
;
9030 ipr_reset_ioa_job(ipr_cmd
);
9034 * ipr_initiate_ioa_reset - Initiate an adapter reset
9035 * @ioa_cfg: ioa config struct
9036 * @shutdown_type: shutdown type
9038 * Description: This function will initiate the reset of the given adapter.
9039 * If the caller needs to wait on the completion of the reset,
9040 * the caller must sleep on the reset_wait_q.
9045 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg
*ioa_cfg
,
9046 enum ipr_shutdown_type shutdown_type
)
9050 if (ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].ioa_is_dead
)
9053 if (ioa_cfg
->in_reset_reload
) {
9054 if (ioa_cfg
->sdt_state
== GET_DUMP
)
9055 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
9056 else if (ioa_cfg
->sdt_state
== READ_DUMP
)
9057 ioa_cfg
->sdt_state
= ABORT_DUMP
;
9060 if (ioa_cfg
->reset_retries
++ >= IPR_NUM_RESET_RELOAD_RETRIES
) {
9061 dev_err(&ioa_cfg
->pdev
->dev
,
9062 "IOA taken offline - error recovery failed\n");
9064 ioa_cfg
->reset_retries
= 0;
9065 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9066 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9067 ioa_cfg
->hrrq
[i
].ioa_is_dead
= 1;
9068 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9072 if (ioa_cfg
->in_ioa_bringdown
) {
9073 ioa_cfg
->reset_cmd
= NULL
;
9074 ioa_cfg
->in_reset_reload
= 0;
9075 ipr_fail_all_ops(ioa_cfg
);
9076 wake_up_all(&ioa_cfg
->reset_wait_q
);
9078 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].removing_ioa
) {
9079 spin_unlock_irq(ioa_cfg
->host
->host_lock
);
9080 scsi_unblock_requests(ioa_cfg
->host
);
9081 spin_lock_irq(ioa_cfg
->host
->host_lock
);
9085 ioa_cfg
->in_ioa_bringdown
= 1;
9086 shutdown_type
= IPR_SHUTDOWN_NONE
;
9090 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_shutdown_ioa
,
9095 * ipr_reset_freeze - Hold off all I/O activity
9096 * @ipr_cmd: ipr command struct
9098 * Description: If the PCI slot is frozen, hold off all I/O
9099 * activity; then, as soon as the slot is available again,
9100 * initiate an adapter reset.
9102 static int ipr_reset_freeze(struct ipr_cmnd
*ipr_cmd
)
9104 struct ipr_ioa_cfg
*ioa_cfg
= ipr_cmd
->ioa_cfg
;
9107 /* Disallow new interrupts, avoid loop */
9108 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9109 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9110 ioa_cfg
->hrrq
[i
].allow_interrupts
= 0;
9111 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9114 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_pending_q
);
9115 ipr_cmd
->done
= ipr_reset_ioa_job
;
9116 return IPR_RC_JOB_RETURN
;
9120 * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9121 * @pdev: PCI device struct
9123 * Description: This routine is called to tell us that the MMIO
9124 * access to the IOA has been restored
9126 static pci_ers_result_t
ipr_pci_mmio_enabled(struct pci_dev
*pdev
)
9128 unsigned long flags
= 0;
9129 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9131 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9132 if (!ioa_cfg
->probe_done
)
9133 pci_save_state(pdev
);
9134 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9135 return PCI_ERS_RESULT_NEED_RESET
;
9139 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9140 * @pdev: PCI device struct
9142 * Description: This routine is called to tell us that the PCI bus
9143 * is down. Can't do anything here, except put the device driver
9144 * into a holding pattern, waiting for the PCI bus to come back.
9146 static void ipr_pci_frozen(struct pci_dev
*pdev
)
9148 unsigned long flags
= 0;
9149 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9151 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9152 if (ioa_cfg
->probe_done
)
9153 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_freeze
, IPR_SHUTDOWN_NONE
);
9154 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9158 * ipr_pci_slot_reset - Called when PCI slot has been reset.
9159 * @pdev: PCI device struct
9161 * Description: This routine is called by the pci error recovery
9162 * code after the PCI slot has been reset, just before we
9163 * should resume normal operations.
9165 static pci_ers_result_t
ipr_pci_slot_reset(struct pci_dev
*pdev
)
9167 unsigned long flags
= 0;
9168 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9170 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9171 if (ioa_cfg
->probe_done
) {
9172 if (ioa_cfg
->needs_warm_reset
)
9173 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9175 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_restore_cfg_space
,
9178 wake_up_all(&ioa_cfg
->eeh_wait_q
);
9179 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9180 return PCI_ERS_RESULT_RECOVERED
;
9184 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9185 * @pdev: PCI device struct
9187 * Description: This routine is called when the PCI bus has
9188 * permanently failed.
9190 static void ipr_pci_perm_failure(struct pci_dev
*pdev
)
9192 unsigned long flags
= 0;
9193 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
9196 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
9197 if (ioa_cfg
->probe_done
) {
9198 if (ioa_cfg
->sdt_state
== WAIT_FOR_DUMP
)
9199 ioa_cfg
->sdt_state
= ABORT_DUMP
;
9200 ioa_cfg
->reset_retries
= IPR_NUM_RESET_RELOAD_RETRIES
- 1;
9201 ioa_cfg
->in_ioa_bringdown
= 1;
9202 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9203 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
9204 ioa_cfg
->hrrq
[i
].allow_cmds
= 0;
9205 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
9208 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9210 wake_up_all(&ioa_cfg
->eeh_wait_q
);
9211 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
9215 * ipr_pci_error_detected - Called when a PCI error is detected.
9216 * @pdev: PCI device struct
9217 * @state: PCI channel state
9219 * Description: Called when a PCI error is detected.
9222 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9224 static pci_ers_result_t
ipr_pci_error_detected(struct pci_dev
*pdev
,
9225 pci_channel_state_t state
)
9228 case pci_channel_io_frozen
:
9229 ipr_pci_frozen(pdev
);
9230 return PCI_ERS_RESULT_CAN_RECOVER
;
9231 case pci_channel_io_perm_failure
:
9232 ipr_pci_perm_failure(pdev
);
9233 return PCI_ERS_RESULT_DISCONNECT
;
9238 return PCI_ERS_RESULT_NEED_RESET
;
9242 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9243 * @ioa_cfg: ioa cfg struct
9245 * Description: This is the second phase of adapter intialization
9246 * This function takes care of initilizing the adapter to the point
9247 * where it can accept new commands.
9250 * 0 on success / -EIO on failure
9252 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg
*ioa_cfg
)
9255 unsigned long host_lock_flags
= 0;
9258 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
9259 dev_dbg(&ioa_cfg
->pdev
->dev
, "ioa_cfg adx: 0x%p\n", ioa_cfg
);
9260 ioa_cfg
->probe_done
= 1;
9261 if (ioa_cfg
->needs_hard_reset
) {
9262 ioa_cfg
->needs_hard_reset
= 0;
9263 ipr_initiate_ioa_reset(ioa_cfg
, IPR_SHUTDOWN_NONE
);
9265 _ipr_initiate_ioa_reset(ioa_cfg
, ipr_reset_enable_ioa
,
9267 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
9274 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9275 * @ioa_cfg: ioa config struct
9280 static void ipr_free_cmd_blks(struct ipr_ioa_cfg
*ioa_cfg
)
9284 if (ioa_cfg
->ipr_cmnd_list
) {
9285 for (i
= 0; i
< IPR_NUM_CMD_BLKS
; i
++) {
9286 if (ioa_cfg
->ipr_cmnd_list
[i
])
9287 dma_pool_free(ioa_cfg
->ipr_cmd_pool
,
9288 ioa_cfg
->ipr_cmnd_list
[i
],
9289 ioa_cfg
->ipr_cmnd_list_dma
[i
]);
9291 ioa_cfg
->ipr_cmnd_list
[i
] = NULL
;
9295 if (ioa_cfg
->ipr_cmd_pool
)
9296 dma_pool_destroy(ioa_cfg
->ipr_cmd_pool
);
9298 kfree(ioa_cfg
->ipr_cmnd_list
);
9299 kfree(ioa_cfg
->ipr_cmnd_list_dma
);
9300 ioa_cfg
->ipr_cmnd_list
= NULL
;
9301 ioa_cfg
->ipr_cmnd_list_dma
= NULL
;
9302 ioa_cfg
->ipr_cmd_pool
= NULL
;
9306 * ipr_free_mem - Frees memory allocated for an adapter
9307 * @ioa_cfg: ioa cfg struct
9312 static void ipr_free_mem(struct ipr_ioa_cfg
*ioa_cfg
)
9316 kfree(ioa_cfg
->res_entries
);
9317 dma_free_coherent(&ioa_cfg
->pdev
->dev
, sizeof(struct ipr_misc_cbs
),
9318 ioa_cfg
->vpd_cbs
, ioa_cfg
->vpd_cbs_dma
);
9319 ipr_free_cmd_blks(ioa_cfg
);
9321 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++)
9322 dma_free_coherent(&ioa_cfg
->pdev
->dev
,
9323 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9324 ioa_cfg
->hrrq
[i
].host_rrq
,
9325 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9327 dma_free_coherent(&ioa_cfg
->pdev
->dev
, ioa_cfg
->cfg_table_size
,
9328 ioa_cfg
->u
.cfg_table
, ioa_cfg
->cfg_table_dma
);
9330 for (i
= 0; i
< IPR_NUM_HCAMS
; i
++) {
9331 dma_free_coherent(&ioa_cfg
->pdev
->dev
,
9332 sizeof(struct ipr_hostrcb
),
9333 ioa_cfg
->hostrcb
[i
],
9334 ioa_cfg
->hostrcb_dma
[i
]);
9337 ipr_free_dump(ioa_cfg
);
9338 kfree(ioa_cfg
->trace
);
9342 * ipr_free_irqs - Free all allocated IRQs for the adapter.
9343 * @ioa_cfg: ipr cfg struct
9345 * This function frees all allocated IRQs for the
9346 * specified adapter.
9351 static void ipr_free_irqs(struct ipr_ioa_cfg
*ioa_cfg
)
9353 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9355 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
||
9356 ioa_cfg
->intr_flag
== IPR_USE_MSIX
) {
9358 for (i
= 0; i
< ioa_cfg
->nvectors
; i
++)
9359 free_irq(ioa_cfg
->vectors_info
[i
].vec
,
9362 free_irq(pdev
->irq
, &ioa_cfg
->hrrq
[0]);
9364 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
) {
9365 pci_disable_msi(pdev
);
9366 ioa_cfg
->intr_flag
&= ~IPR_USE_MSI
;
9367 } else if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
) {
9368 pci_disable_msix(pdev
);
9369 ioa_cfg
->intr_flag
&= ~IPR_USE_MSIX
;
9374 * ipr_free_all_resources - Free all allocated resources for an adapter.
9375 * @ipr_cmd: ipr command struct
9377 * This function frees all allocated resources for the
9378 * specified adapter.
9383 static void ipr_free_all_resources(struct ipr_ioa_cfg
*ioa_cfg
)
9385 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9388 ipr_free_irqs(ioa_cfg
);
9389 if (ioa_cfg
->reset_work_q
)
9390 destroy_workqueue(ioa_cfg
->reset_work_q
);
9391 iounmap(ioa_cfg
->hdw_dma_regs
);
9392 pci_release_regions(pdev
);
9393 ipr_free_mem(ioa_cfg
);
9394 scsi_host_put(ioa_cfg
->host
);
9395 pci_disable_device(pdev
);
9400 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9401 * @ioa_cfg: ioa config struct
9404 * 0 on success / -ENOMEM on allocation failure
9406 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg
*ioa_cfg
)
9408 struct ipr_cmnd
*ipr_cmd
;
9409 struct ipr_ioarcb
*ioarcb
;
9410 dma_addr_t dma_addr
;
9411 int i
, entries_each_hrrq
, hrrq_id
= 0;
9413 ioa_cfg
->ipr_cmd_pool
= dma_pool_create(IPR_NAME
, &ioa_cfg
->pdev
->dev
,
9414 sizeof(struct ipr_cmnd
), 512, 0);
9416 if (!ioa_cfg
->ipr_cmd_pool
)
9419 ioa_cfg
->ipr_cmnd_list
= kcalloc(IPR_NUM_CMD_BLKS
, sizeof(struct ipr_cmnd
*), GFP_KERNEL
);
9420 ioa_cfg
->ipr_cmnd_list_dma
= kcalloc(IPR_NUM_CMD_BLKS
, sizeof(dma_addr_t
), GFP_KERNEL
);
9422 if (!ioa_cfg
->ipr_cmnd_list
|| !ioa_cfg
->ipr_cmnd_list_dma
) {
9423 ipr_free_cmd_blks(ioa_cfg
);
9427 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9428 if (ioa_cfg
->hrrq_num
> 1) {
9430 entries_each_hrrq
= IPR_NUM_INTERNAL_CMD_BLKS
;
9431 ioa_cfg
->hrrq
[i
].min_cmd_id
= 0;
9432 ioa_cfg
->hrrq
[i
].max_cmd_id
=
9433 (entries_each_hrrq
- 1);
9436 IPR_NUM_BASE_CMD_BLKS
/
9437 (ioa_cfg
->hrrq_num
- 1);
9438 ioa_cfg
->hrrq
[i
].min_cmd_id
=
9439 IPR_NUM_INTERNAL_CMD_BLKS
+
9440 (i
- 1) * entries_each_hrrq
;
9441 ioa_cfg
->hrrq
[i
].max_cmd_id
=
9442 (IPR_NUM_INTERNAL_CMD_BLKS
+
9443 i
* entries_each_hrrq
- 1);
9446 entries_each_hrrq
= IPR_NUM_CMD_BLKS
;
9447 ioa_cfg
->hrrq
[i
].min_cmd_id
= 0;
9448 ioa_cfg
->hrrq
[i
].max_cmd_id
= (entries_each_hrrq
- 1);
9450 ioa_cfg
->hrrq
[i
].size
= entries_each_hrrq
;
9453 BUG_ON(ioa_cfg
->hrrq_num
== 0);
9455 i
= IPR_NUM_CMD_BLKS
-
9456 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].max_cmd_id
- 1;
9458 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].size
+= i
;
9459 ioa_cfg
->hrrq
[ioa_cfg
->hrrq_num
- 1].max_cmd_id
+= i
;
9462 for (i
= 0; i
< IPR_NUM_CMD_BLKS
; i
++) {
9463 ipr_cmd
= dma_pool_alloc(ioa_cfg
->ipr_cmd_pool
, GFP_KERNEL
, &dma_addr
);
9466 ipr_free_cmd_blks(ioa_cfg
);
9470 memset(ipr_cmd
, 0, sizeof(*ipr_cmd
));
9471 ioa_cfg
->ipr_cmnd_list
[i
] = ipr_cmd
;
9472 ioa_cfg
->ipr_cmnd_list_dma
[i
] = dma_addr
;
9474 ioarcb
= &ipr_cmd
->ioarcb
;
9475 ipr_cmd
->dma_addr
= dma_addr
;
9477 ioarcb
->a
.ioarcb_host_pci_addr64
= cpu_to_be64(dma_addr
);
9479 ioarcb
->a
.ioarcb_host_pci_addr
= cpu_to_be32(dma_addr
);
9481 ioarcb
->host_response_handle
= cpu_to_be32(i
<< 2);
9482 if (ioa_cfg
->sis64
) {
9483 ioarcb
->u
.sis64_addr_data
.data_ioadl_addr
=
9484 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl64
));
9485 ioarcb
->u
.sis64_addr_data
.ioasa_host_pci_addr
=
9486 cpu_to_be64(dma_addr
+ offsetof(struct ipr_cmnd
, s
.ioasa64
));
9488 ioarcb
->write_ioadl_addr
=
9489 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, i
.ioadl
));
9490 ioarcb
->read_ioadl_addr
= ioarcb
->write_ioadl_addr
;
9491 ioarcb
->ioasa_host_pci_addr
=
9492 cpu_to_be32(dma_addr
+ offsetof(struct ipr_cmnd
, s
.ioasa
));
9494 ioarcb
->ioasa_len
= cpu_to_be16(sizeof(struct ipr_ioasa
));
9495 ipr_cmd
->cmd_index
= i
;
9496 ipr_cmd
->ioa_cfg
= ioa_cfg
;
9497 ipr_cmd
->sense_buffer_dma
= dma_addr
+
9498 offsetof(struct ipr_cmnd
, sense_buffer
);
9500 ipr_cmd
->ioarcb
.cmd_pkt
.hrrq_id
= hrrq_id
;
9501 ipr_cmd
->hrrq
= &ioa_cfg
->hrrq
[hrrq_id
];
9502 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
9503 if (i
>= ioa_cfg
->hrrq
[hrrq_id
].max_cmd_id
)
9511 * ipr_alloc_mem - Allocate memory for an adapter
9512 * @ioa_cfg: ioa config struct
9515 * 0 on success / non-zero for error
9517 static int ipr_alloc_mem(struct ipr_ioa_cfg
*ioa_cfg
)
9519 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9520 int i
, rc
= -ENOMEM
;
9523 ioa_cfg
->res_entries
= kzalloc(sizeof(struct ipr_resource_entry
) *
9524 ioa_cfg
->max_devs_supported
, GFP_KERNEL
);
9526 if (!ioa_cfg
->res_entries
)
9529 for (i
= 0; i
< ioa_cfg
->max_devs_supported
; i
++) {
9530 list_add_tail(&ioa_cfg
->res_entries
[i
].queue
, &ioa_cfg
->free_res_q
);
9531 ioa_cfg
->res_entries
[i
].ioa_cfg
= ioa_cfg
;
9534 ioa_cfg
->vpd_cbs
= dma_alloc_coherent(&pdev
->dev
,
9535 sizeof(struct ipr_misc_cbs
),
9536 &ioa_cfg
->vpd_cbs_dma
,
9539 if (!ioa_cfg
->vpd_cbs
)
9540 goto out_free_res_entries
;
9542 if (ipr_alloc_cmd_blks(ioa_cfg
))
9543 goto out_free_vpd_cbs
;
9545 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9546 ioa_cfg
->hrrq
[i
].host_rrq
= dma_alloc_coherent(&pdev
->dev
,
9547 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9548 &ioa_cfg
->hrrq
[i
].host_rrq_dma
,
9551 if (!ioa_cfg
->hrrq
[i
].host_rrq
) {
9553 dma_free_coherent(&pdev
->dev
,
9554 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9555 ioa_cfg
->hrrq
[i
].host_rrq
,
9556 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9557 goto out_ipr_free_cmd_blocks
;
9559 ioa_cfg
->hrrq
[i
].ioa_cfg
= ioa_cfg
;
9562 ioa_cfg
->u
.cfg_table
= dma_alloc_coherent(&pdev
->dev
,
9563 ioa_cfg
->cfg_table_size
,
9564 &ioa_cfg
->cfg_table_dma
,
9567 if (!ioa_cfg
->u
.cfg_table
)
9568 goto out_free_host_rrq
;
9570 for (i
= 0; i
< IPR_NUM_HCAMS
; i
++) {
9571 ioa_cfg
->hostrcb
[i
] = dma_alloc_coherent(&pdev
->dev
,
9572 sizeof(struct ipr_hostrcb
),
9573 &ioa_cfg
->hostrcb_dma
[i
],
9576 if (!ioa_cfg
->hostrcb
[i
])
9577 goto out_free_hostrcb_dma
;
9579 ioa_cfg
->hostrcb
[i
]->hostrcb_dma
=
9580 ioa_cfg
->hostrcb_dma
[i
] + offsetof(struct ipr_hostrcb
, hcam
);
9581 ioa_cfg
->hostrcb
[i
]->ioa_cfg
= ioa_cfg
;
9582 list_add_tail(&ioa_cfg
->hostrcb
[i
]->queue
, &ioa_cfg
->hostrcb_free_q
);
9585 ioa_cfg
->trace
= kzalloc(sizeof(struct ipr_trace_entry
) *
9586 IPR_NUM_TRACE_ENTRIES
, GFP_KERNEL
);
9588 if (!ioa_cfg
->trace
)
9589 goto out_free_hostrcb_dma
;
9596 out_free_hostrcb_dma
:
9598 dma_free_coherent(&pdev
->dev
, sizeof(struct ipr_hostrcb
),
9599 ioa_cfg
->hostrcb
[i
],
9600 ioa_cfg
->hostrcb_dma
[i
]);
9602 dma_free_coherent(&pdev
->dev
, ioa_cfg
->cfg_table_size
,
9603 ioa_cfg
->u
.cfg_table
, ioa_cfg
->cfg_table_dma
);
9605 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
9606 dma_free_coherent(&pdev
->dev
,
9607 sizeof(u32
) * ioa_cfg
->hrrq
[i
].size
,
9608 ioa_cfg
->hrrq
[i
].host_rrq
,
9609 ioa_cfg
->hrrq
[i
].host_rrq_dma
);
9611 out_ipr_free_cmd_blocks
:
9612 ipr_free_cmd_blks(ioa_cfg
);
9614 dma_free_coherent(&pdev
->dev
, sizeof(struct ipr_misc_cbs
),
9615 ioa_cfg
->vpd_cbs
, ioa_cfg
->vpd_cbs_dma
);
9616 out_free_res_entries
:
9617 kfree(ioa_cfg
->res_entries
);
9622 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9623 * @ioa_cfg: ioa config struct
9628 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg
*ioa_cfg
)
9632 for (i
= 0; i
< IPR_MAX_NUM_BUSES
; i
++) {
9633 ioa_cfg
->bus_attr
[i
].bus
= i
;
9634 ioa_cfg
->bus_attr
[i
].qas_enabled
= 0;
9635 ioa_cfg
->bus_attr
[i
].bus_width
= IPR_DEFAULT_BUS_WIDTH
;
9636 if (ipr_max_speed
< ARRAY_SIZE(ipr_max_bus_speeds
))
9637 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= ipr_max_bus_speeds
[ipr_max_speed
];
9639 ioa_cfg
->bus_attr
[i
].max_xfer_rate
= IPR_U160_SCSI_RATE
;
9644 * ipr_init_regs - Initialize IOA registers
9645 * @ioa_cfg: ioa config struct
9650 static void ipr_init_regs(struct ipr_ioa_cfg
*ioa_cfg
)
9652 const struct ipr_interrupt_offsets
*p
;
9653 struct ipr_interrupts
*t
;
9656 p
= &ioa_cfg
->chip_cfg
->regs
;
9658 base
= ioa_cfg
->hdw_dma_regs
;
9660 t
->set_interrupt_mask_reg
= base
+ p
->set_interrupt_mask_reg
;
9661 t
->clr_interrupt_mask_reg
= base
+ p
->clr_interrupt_mask_reg
;
9662 t
->clr_interrupt_mask_reg32
= base
+ p
->clr_interrupt_mask_reg32
;
9663 t
->sense_interrupt_mask_reg
= base
+ p
->sense_interrupt_mask_reg
;
9664 t
->sense_interrupt_mask_reg32
= base
+ p
->sense_interrupt_mask_reg32
;
9665 t
->clr_interrupt_reg
= base
+ p
->clr_interrupt_reg
;
9666 t
->clr_interrupt_reg32
= base
+ p
->clr_interrupt_reg32
;
9667 t
->sense_interrupt_reg
= base
+ p
->sense_interrupt_reg
;
9668 t
->sense_interrupt_reg32
= base
+ p
->sense_interrupt_reg32
;
9669 t
->ioarrin_reg
= base
+ p
->ioarrin_reg
;
9670 t
->sense_uproc_interrupt_reg
= base
+ p
->sense_uproc_interrupt_reg
;
9671 t
->sense_uproc_interrupt_reg32
= base
+ p
->sense_uproc_interrupt_reg32
;
9672 t
->set_uproc_interrupt_reg
= base
+ p
->set_uproc_interrupt_reg
;
9673 t
->set_uproc_interrupt_reg32
= base
+ p
->set_uproc_interrupt_reg32
;
9674 t
->clr_uproc_interrupt_reg
= base
+ p
->clr_uproc_interrupt_reg
;
9675 t
->clr_uproc_interrupt_reg32
= base
+ p
->clr_uproc_interrupt_reg32
;
9677 if (ioa_cfg
->sis64
) {
9678 t
->init_feedback_reg
= base
+ p
->init_feedback_reg
;
9679 t
->dump_addr_reg
= base
+ p
->dump_addr_reg
;
9680 t
->dump_data_reg
= base
+ p
->dump_data_reg
;
9681 t
->endian_swap_reg
= base
+ p
->endian_swap_reg
;
9686 * ipr_init_ioa_cfg - Initialize IOA config struct
9687 * @ioa_cfg: ioa config struct
9688 * @host: scsi host struct
9689 * @pdev: PCI dev struct
9694 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg
*ioa_cfg
,
9695 struct Scsi_Host
*host
, struct pci_dev
*pdev
)
9699 ioa_cfg
->host
= host
;
9700 ioa_cfg
->pdev
= pdev
;
9701 ioa_cfg
->log_level
= ipr_log_level
;
9702 ioa_cfg
->doorbell
= IPR_DOORBELL
;
9703 sprintf(ioa_cfg
->eye_catcher
, IPR_EYECATCHER
);
9704 sprintf(ioa_cfg
->trace_start
, IPR_TRACE_START_LABEL
);
9705 sprintf(ioa_cfg
->cfg_table_start
, IPR_CFG_TBL_START
);
9706 sprintf(ioa_cfg
->resource_table_label
, IPR_RES_TABLE_LABEL
);
9707 sprintf(ioa_cfg
->ipr_hcam_label
, IPR_HCAM_LABEL
);
9708 sprintf(ioa_cfg
->ipr_cmd_label
, IPR_CMD_LABEL
);
9710 INIT_LIST_HEAD(&ioa_cfg
->hostrcb_free_q
);
9711 INIT_LIST_HEAD(&ioa_cfg
->hostrcb_pending_q
);
9712 INIT_LIST_HEAD(&ioa_cfg
->free_res_q
);
9713 INIT_LIST_HEAD(&ioa_cfg
->used_res_q
);
9714 INIT_WORK(&ioa_cfg
->work_q
, ipr_worker_thread
);
9715 init_waitqueue_head(&ioa_cfg
->reset_wait_q
);
9716 init_waitqueue_head(&ioa_cfg
->msi_wait_q
);
9717 init_waitqueue_head(&ioa_cfg
->eeh_wait_q
);
9718 ioa_cfg
->sdt_state
= INACTIVE
;
9720 ipr_initialize_bus_attr(ioa_cfg
);
9721 ioa_cfg
->max_devs_supported
= ipr_max_devs
;
9723 if (ioa_cfg
->sis64
) {
9724 host
->max_id
= IPR_MAX_SIS64_TARGETS_PER_BUS
;
9725 host
->max_lun
= IPR_MAX_SIS64_LUNS_PER_TARGET
;
9726 if (ipr_max_devs
> IPR_MAX_SIS64_DEVS
)
9727 ioa_cfg
->max_devs_supported
= IPR_MAX_SIS64_DEVS
;
9728 ioa_cfg
->cfg_table_size
= (sizeof(struct ipr_config_table_hdr64
)
9729 + ((sizeof(struct ipr_config_table_entry64
)
9730 * ioa_cfg
->max_devs_supported
)));
9732 host
->max_id
= IPR_MAX_NUM_TARGETS_PER_BUS
;
9733 host
->max_lun
= IPR_MAX_NUM_LUNS_PER_TARGET
;
9734 if (ipr_max_devs
> IPR_MAX_PHYSICAL_DEVS
)
9735 ioa_cfg
->max_devs_supported
= IPR_MAX_PHYSICAL_DEVS
;
9736 ioa_cfg
->cfg_table_size
= (sizeof(struct ipr_config_table_hdr
)
9737 + ((sizeof(struct ipr_config_table_entry
)
9738 * ioa_cfg
->max_devs_supported
)));
9741 host
->max_channel
= IPR_VSET_BUS
;
9742 host
->unique_id
= host
->host_no
;
9743 host
->max_cmd_len
= IPR_MAX_CDB_LEN
;
9744 host
->can_queue
= ioa_cfg
->max_cmds
;
9745 pci_set_drvdata(pdev
, ioa_cfg
);
9747 for (i
= 0; i
< ARRAY_SIZE(ioa_cfg
->hrrq
); i
++) {
9748 INIT_LIST_HEAD(&ioa_cfg
->hrrq
[i
].hrrq_free_q
);
9749 INIT_LIST_HEAD(&ioa_cfg
->hrrq
[i
].hrrq_pending_q
);
9750 spin_lock_init(&ioa_cfg
->hrrq
[i
]._lock
);
9752 ioa_cfg
->hrrq
[i
].lock
= ioa_cfg
->host
->host_lock
;
9754 ioa_cfg
->hrrq
[i
].lock
= &ioa_cfg
->hrrq
[i
]._lock
;
9759 * ipr_get_chip_info - Find adapter chip information
9760 * @dev_id: PCI device id struct
9763 * ptr to chip information on success / NULL on failure
9765 static const struct ipr_chip_t
*
9766 ipr_get_chip_info(const struct pci_device_id
*dev_id
)
9770 for (i
= 0; i
< ARRAY_SIZE(ipr_chip
); i
++)
9771 if (ipr_chip
[i
].vendor
== dev_id
->vendor
&&
9772 ipr_chip
[i
].device
== dev_id
->device
)
9773 return &ipr_chip
[i
];
9778 * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
9780 * @ioa_cfg: ioa config struct
9785 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg
*ioa_cfg
)
9787 struct pci_dev
*pdev
= ioa_cfg
->pdev
;
9789 if (pci_channel_offline(pdev
)) {
9790 wait_event_timeout(ioa_cfg
->eeh_wait_q
,
9791 !pci_channel_offline(pdev
),
9792 IPR_PCI_ERROR_RECOVERY_TIMEOUT
);
9793 pci_restore_state(pdev
);
9797 static int ipr_enable_msix(struct ipr_ioa_cfg
*ioa_cfg
)
9799 struct msix_entry entries
[IPR_MAX_MSIX_VECTORS
];
9802 for (i
= 0; i
< ARRAY_SIZE(entries
); ++i
)
9803 entries
[i
].entry
= i
;
9805 vectors
= pci_enable_msix_range(ioa_cfg
->pdev
,
9806 entries
, 1, ipr_number_of_msix
);
9808 ipr_wait_for_pci_err_recovery(ioa_cfg
);
9812 for (i
= 0; i
< vectors
; i
++)
9813 ioa_cfg
->vectors_info
[i
].vec
= entries
[i
].vector
;
9814 ioa_cfg
->nvectors
= vectors
;
9819 static int ipr_enable_msi(struct ipr_ioa_cfg
*ioa_cfg
)
9823 vectors
= pci_enable_msi_range(ioa_cfg
->pdev
, 1, ipr_number_of_msix
);
9825 ipr_wait_for_pci_err_recovery(ioa_cfg
);
9829 for (i
= 0; i
< vectors
; i
++)
9830 ioa_cfg
->vectors_info
[i
].vec
= ioa_cfg
->pdev
->irq
+ i
;
9831 ioa_cfg
->nvectors
= vectors
;
9836 static void name_msi_vectors(struct ipr_ioa_cfg
*ioa_cfg
)
9838 int vec_idx
, n
= sizeof(ioa_cfg
->vectors_info
[0].desc
) - 1;
9840 for (vec_idx
= 0; vec_idx
< ioa_cfg
->nvectors
; vec_idx
++) {
9841 snprintf(ioa_cfg
->vectors_info
[vec_idx
].desc
, n
,
9842 "host%d-%d", ioa_cfg
->host
->host_no
, vec_idx
);
9843 ioa_cfg
->vectors_info
[vec_idx
].
9844 desc
[strlen(ioa_cfg
->vectors_info
[vec_idx
].desc
)] = 0;
9848 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg
*ioa_cfg
)
9852 for (i
= 1; i
< ioa_cfg
->nvectors
; i
++) {
9853 rc
= request_irq(ioa_cfg
->vectors_info
[i
].vec
,
9856 ioa_cfg
->vectors_info
[i
].desc
,
9860 free_irq(ioa_cfg
->vectors_info
[i
].vec
,
9869 * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
9870 * @pdev: PCI device struct
9872 * Description: Simply set the msi_received flag to 1 indicating that
9873 * Message Signaled Interrupts are supported.
9876 * 0 on success / non-zero on failure
9878 static irqreturn_t
ipr_test_intr(int irq
, void *devp
)
9880 struct ipr_ioa_cfg
*ioa_cfg
= (struct ipr_ioa_cfg
*)devp
;
9881 unsigned long lock_flags
= 0;
9882 irqreturn_t rc
= IRQ_HANDLED
;
9884 dev_info(&ioa_cfg
->pdev
->dev
, "Received IRQ : %d\n", irq
);
9885 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
9887 ioa_cfg
->msi_received
= 1;
9888 wake_up(&ioa_cfg
->msi_wait_q
);
9890 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
9895 * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
9896 * @pdev: PCI device struct
9898 * Description: The return value from pci_enable_msi_range() can not always be
9899 * trusted. This routine sets up and initiates a test interrupt to determine
9900 * if the interrupt is received via the ipr_test_intr() service routine.
9901 * If the tests fails, the driver will fall back to LSI.
9904 * 0 on success / non-zero on failure
9906 static int ipr_test_msi(struct ipr_ioa_cfg
*ioa_cfg
, struct pci_dev
*pdev
)
9909 volatile u32 int_reg
;
9910 unsigned long lock_flags
= 0;
9914 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
9915 init_waitqueue_head(&ioa_cfg
->msi_wait_q
);
9916 ioa_cfg
->msi_received
= 0;
9917 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
9918 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
, ioa_cfg
->regs
.clr_interrupt_mask_reg32
);
9919 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg
);
9920 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
9922 if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
)
9923 rc
= request_irq(ioa_cfg
->vectors_info
[0].vec
, ipr_test_intr
, 0, IPR_NAME
, ioa_cfg
);
9925 rc
= request_irq(pdev
->irq
, ipr_test_intr
, 0, IPR_NAME
, ioa_cfg
);
9927 dev_err(&pdev
->dev
, "Can not assign irq %d\n", pdev
->irq
);
9929 } else if (ipr_debug
)
9930 dev_info(&pdev
->dev
, "IRQ assigned: %d\n", pdev
->irq
);
9932 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE
, ioa_cfg
->regs
.sense_interrupt_reg32
);
9933 int_reg
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
9934 wait_event_timeout(ioa_cfg
->msi_wait_q
, ioa_cfg
->msi_received
, HZ
);
9935 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
9936 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
9938 if (!ioa_cfg
->msi_received
) {
9939 /* MSI test failed */
9940 dev_info(&pdev
->dev
, "MSI test failed. Falling back to LSI.\n");
9942 } else if (ipr_debug
)
9943 dev_info(&pdev
->dev
, "MSI test succeeded.\n");
9945 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
9947 if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
)
9948 free_irq(ioa_cfg
->vectors_info
[0].vec
, ioa_cfg
);
9950 free_irq(pdev
->irq
, ioa_cfg
);
9957 /* ipr_probe_ioa - Allocates memory and does first stage of initialization
9958 * @pdev: PCI device struct
9959 * @dev_id: PCI device id struct
9962 * 0 on success / non-zero on failure
9964 static int ipr_probe_ioa(struct pci_dev
*pdev
,
9965 const struct pci_device_id
*dev_id
)
9967 struct ipr_ioa_cfg
*ioa_cfg
;
9968 struct Scsi_Host
*host
;
9969 unsigned long ipr_regs_pci
;
9970 void __iomem
*ipr_regs
;
9971 int rc
= PCIBIOS_SUCCESSFUL
;
9972 volatile u32 mask
, uproc
, interrupts
;
9973 unsigned long lock_flags
, driver_lock_flags
;
9977 dev_info(&pdev
->dev
, "Found IOA with IRQ: %d\n", pdev
->irq
);
9978 host
= scsi_host_alloc(&driver_template
, sizeof(*ioa_cfg
));
9981 dev_err(&pdev
->dev
, "call to scsi_host_alloc failed!\n");
9986 ioa_cfg
= (struct ipr_ioa_cfg
*)host
->hostdata
;
9987 memset(ioa_cfg
, 0, sizeof(struct ipr_ioa_cfg
));
9988 ata_host_init(&ioa_cfg
->ata_host
, &pdev
->dev
, &ipr_sata_ops
);
9990 ioa_cfg
->ipr_chip
= ipr_get_chip_info(dev_id
);
9992 if (!ioa_cfg
->ipr_chip
) {
9993 dev_err(&pdev
->dev
, "Unknown adapter chipset 0x%04X 0x%04X\n",
9994 dev_id
->vendor
, dev_id
->device
);
9995 goto out_scsi_host_put
;
9998 /* set SIS 32 or SIS 64 */
9999 ioa_cfg
->sis64
= ioa_cfg
->ipr_chip
->sis_type
== IPR_SIS64
? 1 : 0;
10000 ioa_cfg
->chip_cfg
= ioa_cfg
->ipr_chip
->cfg
;
10001 ioa_cfg
->clear_isr
= ioa_cfg
->chip_cfg
->clear_isr
;
10002 ioa_cfg
->max_cmds
= ioa_cfg
->chip_cfg
->max_cmds
;
10004 if (ipr_transop_timeout
)
10005 ioa_cfg
->transop_timeout
= ipr_transop_timeout
;
10006 else if (dev_id
->driver_data
& IPR_USE_LONG_TRANSOP_TIMEOUT
)
10007 ioa_cfg
->transop_timeout
= IPR_LONG_OPERATIONAL_TIMEOUT
;
10009 ioa_cfg
->transop_timeout
= IPR_OPERATIONAL_TIMEOUT
;
10011 ioa_cfg
->revid
= pdev
->revision
;
10013 ipr_init_ioa_cfg(ioa_cfg
, host
, pdev
);
10015 ipr_regs_pci
= pci_resource_start(pdev
, 0);
10017 rc
= pci_request_regions(pdev
, IPR_NAME
);
10019 dev_err(&pdev
->dev
,
10020 "Couldn't register memory range of registers\n");
10021 goto out_scsi_host_put
;
10024 rc
= pci_enable_device(pdev
);
10026 if (rc
|| pci_channel_offline(pdev
)) {
10027 if (pci_channel_offline(pdev
)) {
10028 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10029 rc
= pci_enable_device(pdev
);
10033 dev_err(&pdev
->dev
, "Cannot enable adapter\n");
10034 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10035 goto out_release_regions
;
10039 ipr_regs
= pci_ioremap_bar(pdev
, 0);
10042 dev_err(&pdev
->dev
,
10043 "Couldn't map memory range of registers\n");
10048 ioa_cfg
->hdw_dma_regs
= ipr_regs
;
10049 ioa_cfg
->hdw_dma_regs_pci
= ipr_regs_pci
;
10050 ioa_cfg
->ioa_mailbox
= ioa_cfg
->chip_cfg
->mailbox
+ ipr_regs
;
10052 ipr_init_regs(ioa_cfg
);
10054 if (ioa_cfg
->sis64
) {
10055 rc
= dma_set_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(64));
10057 dev_dbg(&pdev
->dev
, "Failed to set 64 bit DMA mask\n");
10058 rc
= dma_set_mask_and_coherent(&pdev
->dev
,
10062 rc
= dma_set_mask_and_coherent(&pdev
->dev
, DMA_BIT_MASK(32));
10065 dev_err(&pdev
->dev
, "Failed to set DMA mask\n");
10066 goto cleanup_nomem
;
10069 rc
= pci_write_config_byte(pdev
, PCI_CACHE_LINE_SIZE
,
10070 ioa_cfg
->chip_cfg
->cache_line_size
);
10072 if (rc
!= PCIBIOS_SUCCESSFUL
) {
10073 dev_err(&pdev
->dev
, "Write of cache line size failed\n");
10074 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10076 goto cleanup_nomem
;
10079 /* Issue MMIO read to ensure card is not in EEH */
10080 interrupts
= readl(ioa_cfg
->regs
.sense_interrupt_reg
);
10081 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10083 if (ipr_number_of_msix
> IPR_MAX_MSIX_VECTORS
) {
10084 dev_err(&pdev
->dev
, "The max number of MSIX is %d\n",
10085 IPR_MAX_MSIX_VECTORS
);
10086 ipr_number_of_msix
= IPR_MAX_MSIX_VECTORS
;
10089 if (ioa_cfg
->ipr_chip
->intr_type
== IPR_USE_MSI
&&
10090 ipr_enable_msix(ioa_cfg
) == 0)
10091 ioa_cfg
->intr_flag
= IPR_USE_MSIX
;
10092 else if (ioa_cfg
->ipr_chip
->intr_type
== IPR_USE_MSI
&&
10093 ipr_enable_msi(ioa_cfg
) == 0)
10094 ioa_cfg
->intr_flag
= IPR_USE_MSI
;
10096 ioa_cfg
->intr_flag
= IPR_USE_LSI
;
10097 ioa_cfg
->clear_isr
= 1;
10098 ioa_cfg
->nvectors
= 1;
10099 dev_info(&pdev
->dev
, "Cannot enable MSI.\n");
10102 pci_set_master(pdev
);
10104 if (pci_channel_offline(pdev
)) {
10105 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10106 pci_set_master(pdev
);
10107 if (pci_channel_offline(pdev
)) {
10109 goto out_msi_disable
;
10113 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
||
10114 ioa_cfg
->intr_flag
== IPR_USE_MSIX
) {
10115 rc
= ipr_test_msi(ioa_cfg
, pdev
);
10116 if (rc
== -EOPNOTSUPP
) {
10117 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10118 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
) {
10119 ioa_cfg
->intr_flag
&= ~IPR_USE_MSI
;
10120 pci_disable_msi(pdev
);
10121 } else if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
) {
10122 ioa_cfg
->intr_flag
&= ~IPR_USE_MSIX
;
10123 pci_disable_msix(pdev
);
10126 ioa_cfg
->intr_flag
= IPR_USE_LSI
;
10127 ioa_cfg
->nvectors
= 1;
10130 goto out_msi_disable
;
10132 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
)
10133 dev_info(&pdev
->dev
,
10134 "Request for %d MSIs succeeded with starting IRQ: %d\n",
10135 ioa_cfg
->nvectors
, pdev
->irq
);
10136 else if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
)
10137 dev_info(&pdev
->dev
,
10138 "Request for %d MSIXs succeeded.",
10139 ioa_cfg
->nvectors
);
10143 ioa_cfg
->hrrq_num
= min3(ioa_cfg
->nvectors
,
10144 (unsigned int)num_online_cpus(),
10145 (unsigned int)IPR_MAX_HRRQ_NUM
);
10147 if ((rc
= ipr_save_pcix_cmd_reg(ioa_cfg
)))
10148 goto out_msi_disable
;
10150 if ((rc
= ipr_set_pcix_cmd_reg(ioa_cfg
)))
10151 goto out_msi_disable
;
10153 rc
= ipr_alloc_mem(ioa_cfg
);
10155 dev_err(&pdev
->dev
,
10156 "Couldn't allocate enough memory for device driver!\n");
10157 goto out_msi_disable
;
10160 /* Save away PCI config space for use following IOA reset */
10161 rc
= pci_save_state(pdev
);
10163 if (rc
!= PCIBIOS_SUCCESSFUL
) {
10164 dev_err(&pdev
->dev
, "Failed to save PCI config space\n");
10166 goto cleanup_nolog
;
10170 * If HRRQ updated interrupt is not masked, or reset alert is set,
10171 * the card is in an unknown state and needs a hard reset
10173 mask
= readl(ioa_cfg
->regs
.sense_interrupt_mask_reg32
);
10174 interrupts
= readl(ioa_cfg
->regs
.sense_interrupt_reg32
);
10175 uproc
= readl(ioa_cfg
->regs
.sense_uproc_interrupt_reg32
);
10176 if ((mask
& IPR_PCII_HRRQ_UPDATED
) == 0 || (uproc
& IPR_UPROCI_RESET_ALERT
))
10177 ioa_cfg
->needs_hard_reset
= 1;
10178 if ((interrupts
& IPR_PCII_ERROR_INTERRUPTS
) || reset_devices
)
10179 ioa_cfg
->needs_hard_reset
= 1;
10180 if (interrupts
& IPR_PCII_IOA_UNIT_CHECKED
)
10181 ioa_cfg
->ioa_unit_checked
= 1;
10183 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10184 ipr_mask_and_clear_interrupts(ioa_cfg
, ~IPR_PCII_IOA_TRANS_TO_OPER
);
10185 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10187 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
10188 || ioa_cfg
->intr_flag
== IPR_USE_MSIX
) {
10189 name_msi_vectors(ioa_cfg
);
10190 rc
= request_irq(ioa_cfg
->vectors_info
[0].vec
, ipr_isr
,
10192 ioa_cfg
->vectors_info
[0].desc
,
10193 &ioa_cfg
->hrrq
[0]);
10195 rc
= ipr_request_other_msi_irqs(ioa_cfg
);
10197 rc
= request_irq(pdev
->irq
, ipr_isr
,
10199 IPR_NAME
, &ioa_cfg
->hrrq
[0]);
10202 dev_err(&pdev
->dev
, "Couldn't register IRQ %d! rc=%d\n",
10204 goto cleanup_nolog
;
10207 if ((dev_id
->driver_data
& IPR_USE_PCI_WARM_RESET
) ||
10208 (dev_id
->device
== PCI_DEVICE_ID_IBM_OBSIDIAN_E
&& !ioa_cfg
->revid
)) {
10209 ioa_cfg
->needs_warm_reset
= 1;
10210 ioa_cfg
->reset
= ipr_reset_slot_reset
;
10212 ioa_cfg
->reset_work_q
= alloc_ordered_workqueue("ipr_reset_%d",
10213 WQ_MEM_RECLAIM
, host
->host_no
);
10215 if (!ioa_cfg
->reset_work_q
) {
10216 dev_err(&pdev
->dev
, "Couldn't register reset workqueue\n");
10220 ioa_cfg
->reset
= ipr_reset_start_bist
;
10222 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10223 list_add_tail(&ioa_cfg
->queue
, &ipr_ioa_head
);
10224 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10231 ipr_free_irqs(ioa_cfg
);
10233 ipr_free_mem(ioa_cfg
);
10235 ipr_wait_for_pci_err_recovery(ioa_cfg
);
10236 if (ioa_cfg
->intr_flag
== IPR_USE_MSI
)
10237 pci_disable_msi(pdev
);
10238 else if (ioa_cfg
->intr_flag
== IPR_USE_MSIX
)
10239 pci_disable_msix(pdev
);
10243 pci_disable_device(pdev
);
10244 out_release_regions
:
10245 pci_release_regions(pdev
);
10247 scsi_host_put(host
);
10252 * ipr_initiate_ioa_bringdown - Bring down an adapter
10253 * @ioa_cfg: ioa config struct
10254 * @shutdown_type: shutdown type
10256 * Description: This function will initiate bringing down the adapter.
10257 * This consists of issuing an IOA shutdown to the adapter
10258 * to flush the cache, and running BIST.
10259 * If the caller needs to wait on the completion of the reset,
10260 * the caller must sleep on the reset_wait_q.
10265 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg
*ioa_cfg
,
10266 enum ipr_shutdown_type shutdown_type
)
10269 if (ioa_cfg
->sdt_state
== WAIT_FOR_DUMP
)
10270 ioa_cfg
->sdt_state
= ABORT_DUMP
;
10271 ioa_cfg
->reset_retries
= 0;
10272 ioa_cfg
->in_ioa_bringdown
= 1;
10273 ipr_initiate_ioa_reset(ioa_cfg
, shutdown_type
);
10278 * __ipr_remove - Remove a single adapter
10279 * @pdev: pci device struct
10281 * Adapter hot plug remove entry point.
10286 static void __ipr_remove(struct pci_dev
*pdev
)
10288 unsigned long host_lock_flags
= 0;
10289 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10291 unsigned long driver_lock_flags
;
10294 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10295 while (ioa_cfg
->in_reset_reload
) {
10296 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10297 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10298 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10301 for (i
= 0; i
< ioa_cfg
->hrrq_num
; i
++) {
10302 spin_lock(&ioa_cfg
->hrrq
[i
]._lock
);
10303 ioa_cfg
->hrrq
[i
].removing_ioa
= 1;
10304 spin_unlock(&ioa_cfg
->hrrq
[i
]._lock
);
10307 ipr_initiate_ioa_bringdown(ioa_cfg
, IPR_SHUTDOWN_NORMAL
);
10309 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10310 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10311 flush_work(&ioa_cfg
->work_q
);
10312 if (ioa_cfg
->reset_work_q
)
10313 flush_workqueue(ioa_cfg
->reset_work_q
);
10314 INIT_LIST_HEAD(&ioa_cfg
->used_res_q
);
10315 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10317 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10318 list_del(&ioa_cfg
->queue
);
10319 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10321 if (ioa_cfg
->sdt_state
== ABORT_DUMP
)
10322 ioa_cfg
->sdt_state
= WAIT_FOR_DUMP
;
10323 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, host_lock_flags
);
10325 ipr_free_all_resources(ioa_cfg
);
10331 * ipr_remove - IOA hot plug remove entry point
10332 * @pdev: pci device struct
10334 * Adapter hot plug remove entry point.
10339 static void ipr_remove(struct pci_dev
*pdev
)
10341 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10345 ipr_remove_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10347 ipr_remove_dump_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10349 scsi_remove_host(ioa_cfg
->host
);
10351 __ipr_remove(pdev
);
10357 * ipr_probe - Adapter hot plug add entry point
10360 * 0 on success / non-zero on failure
10362 static int ipr_probe(struct pci_dev
*pdev
, const struct pci_device_id
*dev_id
)
10364 struct ipr_ioa_cfg
*ioa_cfg
;
10367 rc
= ipr_probe_ioa(pdev
, dev_id
);
10372 ioa_cfg
= pci_get_drvdata(pdev
);
10373 rc
= ipr_probe_ioa_part2(ioa_cfg
);
10376 __ipr_remove(pdev
);
10380 rc
= scsi_add_host(ioa_cfg
->host
, &pdev
->dev
);
10383 __ipr_remove(pdev
);
10387 rc
= ipr_create_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10391 scsi_remove_host(ioa_cfg
->host
);
10392 __ipr_remove(pdev
);
10396 rc
= ipr_create_dump_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10400 ipr_remove_trace_file(&ioa_cfg
->host
->shost_dev
.kobj
,
10402 scsi_remove_host(ioa_cfg
->host
);
10403 __ipr_remove(pdev
);
10407 scsi_scan_host(ioa_cfg
->host
);
10408 ioa_cfg
->iopoll_weight
= ioa_cfg
->chip_cfg
->iopoll_weight
;
10410 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
10411 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++) {
10412 irq_poll_init(&ioa_cfg
->hrrq
[i
].iopoll
,
10413 ioa_cfg
->iopoll_weight
, ipr_iopoll
);
10417 schedule_work(&ioa_cfg
->work_q
);
10422 * ipr_shutdown - Shutdown handler.
10423 * @pdev: pci device struct
10425 * This function is invoked upon system shutdown/reboot. It will issue
10426 * an adapter shutdown to the adapter to flush the write cache.
10431 static void ipr_shutdown(struct pci_dev
*pdev
)
10433 struct ipr_ioa_cfg
*ioa_cfg
= pci_get_drvdata(pdev
);
10434 unsigned long lock_flags
= 0;
10435 enum ipr_shutdown_type shutdown_type
= IPR_SHUTDOWN_NORMAL
;
10438 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10439 if (ioa_cfg
->iopoll_weight
&& ioa_cfg
->sis64
&& ioa_cfg
->nvectors
> 1) {
10440 ioa_cfg
->iopoll_weight
= 0;
10441 for (i
= 1; i
< ioa_cfg
->hrrq_num
; i
++)
10442 irq_poll_disable(&ioa_cfg
->hrrq
[i
].iopoll
);
10445 while (ioa_cfg
->in_reset_reload
) {
10446 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10447 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10448 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, lock_flags
);
10451 if (ipr_fast_reboot
&& system_state
== SYSTEM_RESTART
&& ioa_cfg
->sis64
)
10452 shutdown_type
= IPR_SHUTDOWN_QUIESCE
;
10454 ipr_initiate_ioa_bringdown(ioa_cfg
, shutdown_type
);
10455 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, lock_flags
);
10456 wait_event(ioa_cfg
->reset_wait_q
, !ioa_cfg
->in_reset_reload
);
10457 if (ipr_fast_reboot
&& system_state
== SYSTEM_RESTART
&& ioa_cfg
->sis64
) {
10458 ipr_free_irqs(ioa_cfg
);
10459 pci_disable_device(ioa_cfg
->pdev
);
10463 static struct pci_device_id ipr_pci_table
[] = {
10464 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10465 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_5702
, 0, 0, 0 },
10466 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10467 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_5703
, 0, 0, 0 },
10468 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10469 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_573D
, 0, 0, 0 },
10470 { PCI_VENDOR_ID_MYLEX
, PCI_DEVICE_ID_IBM_GEMSTONE
,
10471 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_573E
, 0, 0, 0 },
10472 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10473 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571B
, 0, 0, 0 },
10474 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10475 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572E
, 0, 0, 0 },
10476 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10477 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571A
, 0, 0, 0 },
10478 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CITRINE
,
10479 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575B
, 0, 0,
10480 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10481 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10482 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572A
, 0, 0, 0 },
10483 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10484 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572B
, 0, 0,
10485 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10486 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN
,
10487 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575C
, 0, 0,
10488 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10489 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10490 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572A
, 0, 0, 0 },
10491 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10492 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572B
, 0, 0,
10493 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10494 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN
,
10495 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_575C
, 0, 0,
10496 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10497 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10498 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_574E
, 0, 0,
10499 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10500 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10501 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B3
, 0, 0, 0 },
10502 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10503 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57CC
, 0, 0, 0 },
10504 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_OBSIDIAN_E
,
10505 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B7
, 0, 0,
10506 IPR_USE_LONG_TRANSOP_TIMEOUT
| IPR_USE_PCI_WARM_RESET
},
10507 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_SNIPE
,
10508 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2780
, 0, 0, 0 },
10509 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10510 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571E
, 0, 0, 0 },
10511 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10512 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_571F
, 0, 0,
10513 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10514 { PCI_VENDOR_ID_ADAPTEC2
, PCI_DEVICE_ID_ADAPTEC2_SCAMP
,
10515 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_572F
, 0, 0,
10516 IPR_USE_LONG_TRANSOP_TIMEOUT
},
10517 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10518 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B5
, 0, 0, 0 },
10519 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10520 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_574D
, 0, 0, 0 },
10521 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10522 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B2
, 0, 0, 0 },
10523 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10524 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C0
, 0, 0, 0 },
10525 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10526 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C3
, 0, 0, 0 },
10527 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROC_FPGA_E2
,
10528 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C4
, 0, 0, 0 },
10529 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10530 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B4
, 0, 0, 0 },
10531 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10532 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57B1
, 0, 0, 0 },
10533 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10534 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C6
, 0, 0, 0 },
10535 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10536 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57C8
, 0, 0, 0 },
10537 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10538 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57CE
, 0, 0, 0 },
10539 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10540 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D5
, 0, 0, 0 },
10541 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10542 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D6
, 0, 0, 0 },
10543 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10544 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D7
, 0, 0, 0 },
10545 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10546 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D8
, 0, 0, 0 },
10547 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10548 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57D9
, 0, 0, 0 },
10549 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10550 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57DA
, 0, 0, 0 },
10551 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10552 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EB
, 0, 0, 0 },
10553 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10554 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EC
, 0, 0, 0 },
10555 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10556 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57ED
, 0, 0, 0 },
10557 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10558 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EE
, 0, 0, 0 },
10559 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10560 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57EF
, 0, 0, 0 },
10561 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10562 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_57F0
, 0, 0, 0 },
10563 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10564 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CCA
, 0, 0, 0 },
10565 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10566 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CD2
, 0, 0, 0 },
10567 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_CROCODILE
,
10568 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_2CCD
, 0, 0, 0 },
10569 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_RATTLESNAKE
,
10570 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_580A
, 0, 0, 0 },
10571 { PCI_VENDOR_ID_IBM
, PCI_DEVICE_ID_IBM_RATTLESNAKE
,
10572 PCI_VENDOR_ID_IBM
, IPR_SUBS_DEV_ID_580B
, 0, 0, 0 },
10575 MODULE_DEVICE_TABLE(pci
, ipr_pci_table
);
10577 static const struct pci_error_handlers ipr_err_handler
= {
10578 .error_detected
= ipr_pci_error_detected
,
10579 .mmio_enabled
= ipr_pci_mmio_enabled
,
10580 .slot_reset
= ipr_pci_slot_reset
,
10583 static struct pci_driver ipr_driver
= {
10585 .id_table
= ipr_pci_table
,
10586 .probe
= ipr_probe
,
10587 .remove
= ipr_remove
,
10588 .shutdown
= ipr_shutdown
,
10589 .err_handler
= &ipr_err_handler
,
10593 * ipr_halt_done - Shutdown prepare completion
10598 static void ipr_halt_done(struct ipr_cmnd
*ipr_cmd
)
10600 list_add_tail(&ipr_cmd
->queue
, &ipr_cmd
->hrrq
->hrrq_free_q
);
10604 * ipr_halt - Issue shutdown prepare to all adapters
10607 * NOTIFY_OK on success / NOTIFY_DONE on failure
10609 static int ipr_halt(struct notifier_block
*nb
, ulong event
, void *buf
)
10611 struct ipr_cmnd
*ipr_cmd
;
10612 struct ipr_ioa_cfg
*ioa_cfg
;
10613 unsigned long flags
= 0, driver_lock_flags
;
10615 if (event
!= SYS_RESTART
&& event
!= SYS_HALT
&& event
!= SYS_POWER_OFF
)
10616 return NOTIFY_DONE
;
10618 spin_lock_irqsave(&ipr_driver_lock
, driver_lock_flags
);
10620 list_for_each_entry(ioa_cfg
, &ipr_ioa_head
, queue
) {
10621 spin_lock_irqsave(ioa_cfg
->host
->host_lock
, flags
);
10622 if (!ioa_cfg
->hrrq
[IPR_INIT_HRRQ
].allow_cmds
||
10623 (ipr_fast_reboot
&& event
== SYS_RESTART
&& ioa_cfg
->sis64
)) {
10624 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
10628 ipr_cmd
= ipr_get_free_ipr_cmnd(ioa_cfg
);
10629 ipr_cmd
->ioarcb
.res_handle
= cpu_to_be32(IPR_IOA_RES_HANDLE
);
10630 ipr_cmd
->ioarcb
.cmd_pkt
.request_type
= IPR_RQTYPE_IOACMD
;
10631 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[0] = IPR_IOA_SHUTDOWN
;
10632 ipr_cmd
->ioarcb
.cmd_pkt
.cdb
[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL
;
10634 ipr_do_req(ipr_cmd
, ipr_halt_done
, ipr_timeout
, IPR_DEVICE_RESET_TIMEOUT
);
10635 spin_unlock_irqrestore(ioa_cfg
->host
->host_lock
, flags
);
10637 spin_unlock_irqrestore(&ipr_driver_lock
, driver_lock_flags
);
10642 static struct notifier_block ipr_notifier
= {
10647 * ipr_init - Module entry point
10650 * 0 on success / negative value on failure
10652 static int __init
ipr_init(void)
10654 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10655 IPR_DRIVER_VERSION
, IPR_DRIVER_DATE
);
10657 register_reboot_notifier(&ipr_notifier
);
10658 return pci_register_driver(&ipr_driver
);
10662 * ipr_exit - Module unload
10664 * Module unload entry point.
10669 static void __exit
ipr_exit(void)
10671 unregister_reboot_notifier(&ipr_notifier
);
10672 pci_unregister_driver(&ipr_driver
);
10675 module_init(ipr_init
);
10676 module_exit(ipr_exit
);