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