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