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