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