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