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

source code of linux/drivers/scsi/ipr.c