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