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