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