Merge tag 'for-3.7' of git://git.kernel.org/pub/scm/linux/kernel/git/helgaas/pci
[linux-3.10.git] / drivers / scsi / ipr.c
1 /*
2  * ipr.c -- driver for IBM Power Linux RAID adapters
3  *
4  * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
5  *
6  * Copyright (C) 2003, 2004 IBM Corporation
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the GNU General Public License as published by
10  * the Free Software Foundation; either version 2 of the License, or
11  * (at your option) any later version.
12  *
13  * This program is distributed in the hope that it will be useful,
14  * but WITHOUT ANY WARRANTY; without even the implied warranty of
15  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
16  * GNU General Public License for more details.
17  *
18  * You should have received a copy of the GNU General Public License
19  * along with this program; if not, write to the Free Software
20  * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
21  *
22  */
23
24 /*
25  * Notes:
26  *
27  * This driver is used to control the following SCSI adapters:
28  *
29  * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
30  *
31  * IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
32  *              PCI-X Dual Channel Ultra 320 SCSI Adapter
33  *              PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
34  *              Embedded SCSI adapter on p615 and p655 systems
35  *
36  * Supported Hardware Features:
37  *      - Ultra 320 SCSI controller
38  *      - PCI-X host interface
39  *      - Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
40  *      - Non-Volatile Write Cache
41  *      - Supports attachment of non-RAID disks, tape, and optical devices
42  *      - RAID Levels 0, 5, 10
43  *      - Hot spare
44  *      - Background Parity Checking
45  *      - Background Data Scrubbing
46  *      - Ability to increase the capacity of an existing RAID 5 disk array
47  *              by adding disks
48  *
49  * Driver Features:
50  *      - Tagged command queuing
51  *      - Adapter microcode download
52  *      - PCI hot plug
53  *      - SCSI device hot plug
54  *
55  */
56
57 #include <linux/fs.h>
58 #include <linux/init.h>
59 #include <linux/types.h>
60 #include <linux/errno.h>
61 #include <linux/kernel.h>
62 #include <linux/slab.h>
63 #include <linux/vmalloc.h>
64 #include <linux/ioport.h>
65 #include <linux/delay.h>
66 #include <linux/pci.h>
67 #include <linux/wait.h>
68 #include <linux/spinlock.h>
69 #include <linux/sched.h>
70 #include <linux/interrupt.h>
71 #include <linux/blkdev.h>
72 #include <linux/firmware.h>
73 #include <linux/module.h>
74 #include <linux/moduleparam.h>
75 #include <linux/libata.h>
76 #include <linux/hdreg.h>
77 #include <linux/reboot.h>
78 #include <linux/stringify.h>
79 #include <asm/io.h>
80 #include <asm/irq.h>
81 #include <asm/processor.h>
82 #include <scsi/scsi.h>
83 #include <scsi/scsi_host.h>
84 #include <scsi/scsi_tcq.h>
85 #include <scsi/scsi_eh.h>
86 #include <scsi/scsi_cmnd.h>
87 #include "ipr.h"
88
89 /*
90  *   Global Data
91  */
92 static LIST_HEAD(ipr_ioa_head);
93 static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
94 static unsigned int ipr_max_speed = 1;
95 static int ipr_testmode = 0;
96 static unsigned int ipr_fastfail = 0;
97 static unsigned int ipr_transop_timeout = 0;
98 static unsigned int ipr_debug = 0;
99 static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
100 static unsigned int ipr_dual_ioa_raid = 1;
101 static DEFINE_SPINLOCK(ipr_driver_lock);
102
103 /* This table describes the differences between DMA controller chips */
104 static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
105         { /* Gemstone, Citrine, Obsidian, and Obsidian-E */
106                 .mailbox = 0x0042C,
107                 .max_cmds = 100,
108                 .cache_line_size = 0x20,
109                 .clear_isr = 1,
110                 {
111                         .set_interrupt_mask_reg = 0x0022C,
112                         .clr_interrupt_mask_reg = 0x00230,
113                         .clr_interrupt_mask_reg32 = 0x00230,
114                         .sense_interrupt_mask_reg = 0x0022C,
115                         .sense_interrupt_mask_reg32 = 0x0022C,
116                         .clr_interrupt_reg = 0x00228,
117                         .clr_interrupt_reg32 = 0x00228,
118                         .sense_interrupt_reg = 0x00224,
119                         .sense_interrupt_reg32 = 0x00224,
120                         .ioarrin_reg = 0x00404,
121                         .sense_uproc_interrupt_reg = 0x00214,
122                         .sense_uproc_interrupt_reg32 = 0x00214,
123                         .set_uproc_interrupt_reg = 0x00214,
124                         .set_uproc_interrupt_reg32 = 0x00214,
125                         .clr_uproc_interrupt_reg = 0x00218,
126                         .clr_uproc_interrupt_reg32 = 0x00218
127                 }
128         },
129         { /* Snipe and Scamp */
130                 .mailbox = 0x0052C,
131                 .max_cmds = 100,
132                 .cache_line_size = 0x20,
133                 .clear_isr = 1,
134                 {
135                         .set_interrupt_mask_reg = 0x00288,
136                         .clr_interrupt_mask_reg = 0x0028C,
137                         .clr_interrupt_mask_reg32 = 0x0028C,
138                         .sense_interrupt_mask_reg = 0x00288,
139                         .sense_interrupt_mask_reg32 = 0x00288,
140                         .clr_interrupt_reg = 0x00284,
141                         .clr_interrupt_reg32 = 0x00284,
142                         .sense_interrupt_reg = 0x00280,
143                         .sense_interrupt_reg32 = 0x00280,
144                         .ioarrin_reg = 0x00504,
145                         .sense_uproc_interrupt_reg = 0x00290,
146                         .sense_uproc_interrupt_reg32 = 0x00290,
147                         .set_uproc_interrupt_reg = 0x00290,
148                         .set_uproc_interrupt_reg32 = 0x00290,
149                         .clr_uproc_interrupt_reg = 0x00294,
150                         .clr_uproc_interrupt_reg32 = 0x00294
151                 }
152         },
153         { /* CRoC */
154                 .mailbox = 0x00044,
155                 .max_cmds = 1000,
156                 .cache_line_size = 0x20,
157                 .clear_isr = 0,
158                 {
159                         .set_interrupt_mask_reg = 0x00010,
160                         .clr_interrupt_mask_reg = 0x00018,
161                         .clr_interrupt_mask_reg32 = 0x0001C,
162                         .sense_interrupt_mask_reg = 0x00010,
163                         .sense_interrupt_mask_reg32 = 0x00014,
164                         .clr_interrupt_reg = 0x00008,
165                         .clr_interrupt_reg32 = 0x0000C,
166                         .sense_interrupt_reg = 0x00000,
167                         .sense_interrupt_reg32 = 0x00004,
168                         .ioarrin_reg = 0x00070,
169                         .sense_uproc_interrupt_reg = 0x00020,
170                         .sense_uproc_interrupt_reg32 = 0x00024,
171                         .set_uproc_interrupt_reg = 0x00020,
172                         .set_uproc_interrupt_reg32 = 0x00024,
173                         .clr_uproc_interrupt_reg = 0x00028,
174                         .clr_uproc_interrupt_reg32 = 0x0002C,
175                         .init_feedback_reg = 0x0005C,
176                         .dump_addr_reg = 0x00064,
177                         .dump_data_reg = 0x00068,
178                         .endian_swap_reg = 0x00084
179                 }
180         },
181 };
182
183 static const struct ipr_chip_t ipr_chip[] = {
184         { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
185         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
186         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
187         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
188         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
189         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
190         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
191         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
192         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
193 };
194
195 static int ipr_max_bus_speeds[] = {
196         IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
197 };
198
199 MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
200 MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
201 module_param_named(max_speed, ipr_max_speed, uint, 0);
202 MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
203 module_param_named(log_level, ipr_log_level, uint, 0);
204 MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
205 module_param_named(testmode, ipr_testmode, int, 0);
206 MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
207 module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
208 MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
209 module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
210 MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
211 module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
212 MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
213 module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
214 MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
215 module_param_named(max_devs, ipr_max_devs, int, 0);
216 MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
217                  "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
218 MODULE_LICENSE("GPL");
219 MODULE_VERSION(IPR_DRIVER_VERSION);
220
221 /*  A constant array of IOASCs/URCs/Error Messages */
222 static const
223 struct ipr_error_table_t ipr_error_table[] = {
224         {0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
225         "8155: An unknown error was received"},
226         {0x00330000, 0, 0,
227         "Soft underlength error"},
228         {0x005A0000, 0, 0,
229         "Command to be cancelled not found"},
230         {0x00808000, 0, 0,
231         "Qualified success"},
232         {0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
233         "FFFE: Soft device bus error recovered by the IOA"},
234         {0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
235         "4101: Soft device bus fabric error"},
236         {0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
237         "FFFC: Logical block guard error recovered by the device"},
238         {0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
239         "FFFC: Logical block reference tag error recovered by the device"},
240         {0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
241         "4171: Recovered scatter list tag / sequence number error"},
242         {0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
243         "FF3D: Recovered logical block CRC error on IOA to Host transfer"},
244         {0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
245         "4171: Recovered logical block sequence number error on IOA to Host transfer"},
246         {0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
247         "FFFD: Recovered logical block reference tag error detected by the IOA"},
248         {0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
249         "FFFD: Logical block guard error recovered by the IOA"},
250         {0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
251         "FFF9: Device sector reassign successful"},
252         {0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
253         "FFF7: Media error recovered by device rewrite procedures"},
254         {0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
255         "7001: IOA sector reassignment successful"},
256         {0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
257         "FFF9: Soft media error. Sector reassignment recommended"},
258         {0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
259         "FFF7: Media error recovered by IOA rewrite procedures"},
260         {0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
261         "FF3D: Soft PCI bus error recovered by the IOA"},
262         {0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
263         "FFF6: Device hardware error recovered by the IOA"},
264         {0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
265         "FFF6: Device hardware error recovered by the device"},
266         {0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
267         "FF3D: Soft IOA error recovered by the IOA"},
268         {0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
269         "FFFA: Undefined device response recovered by the IOA"},
270         {0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
271         "FFF6: Device bus error, message or command phase"},
272         {0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
273         "FFFE: Task Management Function failed"},
274         {0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
275         "FFF6: Failure prediction threshold exceeded"},
276         {0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
277         "8009: Impending cache battery pack failure"},
278         {0x02040400, 0, 0,
279         "34FF: Disk device format in progress"},
280         {0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
281         "9070: IOA requested reset"},
282         {0x023F0000, 0, 0,
283         "Synchronization required"},
284         {0x024E0000, 0, 0,
285         "No ready, IOA shutdown"},
286         {0x025A0000, 0, 0,
287         "Not ready, IOA has been shutdown"},
288         {0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
289         "3020: Storage subsystem configuration error"},
290         {0x03110B00, 0, 0,
291         "FFF5: Medium error, data unreadable, recommend reassign"},
292         {0x03110C00, 0, 0,
293         "7000: Medium error, data unreadable, do not reassign"},
294         {0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
295         "FFF3: Disk media format bad"},
296         {0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
297         "3002: Addressed device failed to respond to selection"},
298         {0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
299         "3100: Device bus error"},
300         {0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
301         "3109: IOA timed out a device command"},
302         {0x04088000, 0, 0,
303         "3120: SCSI bus is not operational"},
304         {0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
305         "4100: Hard device bus fabric error"},
306         {0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
307         "310C: Logical block guard error detected by the device"},
308         {0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
309         "310C: Logical block reference tag error detected by the device"},
310         {0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
311         "4170: Scatter list tag / sequence number error"},
312         {0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
313         "8150: Logical block CRC error on IOA to Host transfer"},
314         {0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
315         "4170: Logical block sequence number error on IOA to Host transfer"},
316         {0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
317         "310D: Logical block reference tag error detected by the IOA"},
318         {0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
319         "310D: Logical block guard error detected by the IOA"},
320         {0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
321         "9000: IOA reserved area data check"},
322         {0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
323         "9001: IOA reserved area invalid data pattern"},
324         {0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
325         "9002: IOA reserved area LRC error"},
326         {0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
327         "Hardware Error, IOA metadata access error"},
328         {0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
329         "102E: Out of alternate sectors for disk storage"},
330         {0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
331         "FFF4: Data transfer underlength error"},
332         {0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
333         "FFF4: Data transfer overlength error"},
334         {0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
335         "3400: Logical unit failure"},
336         {0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
337         "FFF4: Device microcode is corrupt"},
338         {0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
339         "8150: PCI bus error"},
340         {0x04430000, 1, 0,
341         "Unsupported device bus message received"},
342         {0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
343         "FFF4: Disk device problem"},
344         {0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
345         "8150: Permanent IOA failure"},
346         {0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
347         "3010: Disk device returned wrong response to IOA"},
348         {0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
349         "8151: IOA microcode error"},
350         {0x04448500, 0, 0,
351         "Device bus status error"},
352         {0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
353         "8157: IOA error requiring IOA reset to recover"},
354         {0x04448700, 0, 0,
355         "ATA device status error"},
356         {0x04490000, 0, 0,
357         "Message reject received from the device"},
358         {0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
359         "8008: A permanent cache battery pack failure occurred"},
360         {0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
361         "9090: Disk unit has been modified after the last known status"},
362         {0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
363         "9081: IOA detected device error"},
364         {0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
365         "9082: IOA detected device error"},
366         {0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
367         "3110: Device bus error, message or command phase"},
368         {0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
369         "3110: SAS Command / Task Management Function failed"},
370         {0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
371         "9091: Incorrect hardware configuration change has been detected"},
372         {0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
373         "9073: Invalid multi-adapter configuration"},
374         {0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
375         "4010: Incorrect connection between cascaded expanders"},
376         {0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
377         "4020: Connections exceed IOA design limits"},
378         {0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
379         "4030: Incorrect multipath connection"},
380         {0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
381         "4110: Unsupported enclosure function"},
382         {0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
383         "FFF4: Command to logical unit failed"},
384         {0x05240000, 1, 0,
385         "Illegal request, invalid request type or request packet"},
386         {0x05250000, 0, 0,
387         "Illegal request, invalid resource handle"},
388         {0x05258000, 0, 0,
389         "Illegal request, commands not allowed to this device"},
390         {0x05258100, 0, 0,
391         "Illegal request, command not allowed to a secondary adapter"},
392         {0x05258200, 0, 0,
393         "Illegal request, command not allowed to a non-optimized resource"},
394         {0x05260000, 0, 0,
395         "Illegal request, invalid field in parameter list"},
396         {0x05260100, 0, 0,
397         "Illegal request, parameter not supported"},
398         {0x05260200, 0, 0,
399         "Illegal request, parameter value invalid"},
400         {0x052C0000, 0, 0,
401         "Illegal request, command sequence error"},
402         {0x052C8000, 1, 0,
403         "Illegal request, dual adapter support not enabled"},
404         {0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
405         "9031: Array protection temporarily suspended, protection resuming"},
406         {0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
407         "9040: Array protection temporarily suspended, protection resuming"},
408         {0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
409         "3140: Device bus not ready to ready transition"},
410         {0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
411         "FFFB: SCSI bus was reset"},
412         {0x06290500, 0, 0,
413         "FFFE: SCSI bus transition to single ended"},
414         {0x06290600, 0, 0,
415         "FFFE: SCSI bus transition to LVD"},
416         {0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
417         "FFFB: SCSI bus was reset by another initiator"},
418         {0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
419         "3029: A device replacement has occurred"},
420         {0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
421         "9051: IOA cache data exists for a missing or failed device"},
422         {0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
423         "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
424         {0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
425         "9025: Disk unit is not supported at its physical location"},
426         {0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
427         "3020: IOA detected a SCSI bus configuration error"},
428         {0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
429         "3150: SCSI bus configuration error"},
430         {0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
431         "9074: Asymmetric advanced function disk configuration"},
432         {0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
433         "4040: Incomplete multipath connection between IOA and enclosure"},
434         {0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
435         "4041: Incomplete multipath connection between enclosure and device"},
436         {0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
437         "9075: Incomplete multipath connection between IOA and remote IOA"},
438         {0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
439         "9076: Configuration error, missing remote IOA"},
440         {0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
441         "4050: Enclosure does not support a required multipath function"},
442         {0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
443         "4070: Logically bad block written on device"},
444         {0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
445         "9041: Array protection temporarily suspended"},
446         {0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
447         "9042: Corrupt array parity detected on specified device"},
448         {0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
449         "9030: Array no longer protected due to missing or failed disk unit"},
450         {0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
451         "9071: Link operational transition"},
452         {0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
453         "9072: Link not operational transition"},
454         {0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
455         "9032: Array exposed but still protected"},
456         {0x066B8300, 0, IPR_DEFAULT_LOG_LEVEL + 1,
457         "70DD: Device forced failed by disrupt device command"},
458         {0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
459         "4061: Multipath redundancy level got better"},
460         {0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
461         "4060: Multipath redundancy level got worse"},
462         {0x07270000, 0, 0,
463         "Failure due to other device"},
464         {0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
465         "9008: IOA does not support functions expected by devices"},
466         {0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
467         "9010: Cache data associated with attached devices cannot be found"},
468         {0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
469         "9011: Cache data belongs to devices other than those attached"},
470         {0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
471         "9020: Array missing 2 or more devices with only 1 device present"},
472         {0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
473         "9021: Array missing 2 or more devices with 2 or more devices present"},
474         {0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
475         "9022: Exposed array is missing a required device"},
476         {0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
477         "9023: Array member(s) not at required physical locations"},
478         {0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
479         "9024: Array not functional due to present hardware configuration"},
480         {0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
481         "9026: Array not functional due to present hardware configuration"},
482         {0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
483         "9027: Array is missing a device and parity is out of sync"},
484         {0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
485         "9028: Maximum number of arrays already exist"},
486         {0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
487         "9050: Required cache data cannot be located for a disk unit"},
488         {0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
489         "9052: Cache data exists for a device that has been modified"},
490         {0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
491         "9054: IOA resources not available due to previous problems"},
492         {0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
493         "9092: Disk unit requires initialization before use"},
494         {0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
495         "9029: Incorrect hardware configuration change has been detected"},
496         {0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
497         "9060: One or more disk pairs are missing from an array"},
498         {0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
499         "9061: One or more disks are missing from an array"},
500         {0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
501         "9062: One or more disks are missing from an array"},
502         {0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
503         "9063: Maximum number of functional arrays has been exceeded"},
504         {0x0B260000, 0, 0,
505         "Aborted command, invalid descriptor"},
506         {0x0B5A0000, 0, 0,
507         "Command terminated by host"}
508 };
509
510 static const struct ipr_ses_table_entry ipr_ses_table[] = {
511         { "2104-DL1        ", "XXXXXXXXXXXXXXXX", 80 },
512         { "2104-TL1        ", "XXXXXXXXXXXXXXXX", 80 },
513         { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
514         { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
515         { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
516         { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
517         { "2104-DU3        ", "XXXXXXXXXXXXXXXX", 160 },
518         { "2104-TU3        ", "XXXXXXXXXXXXXXXX", 160 },
519         { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
520         { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
521         { "St  V1S2        ", "XXXXXXXXXXXXXXXX", 160 },
522         { "HSBPD4M  PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
523         { "VSBPD1H   U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
524 };
525
526 /*
527  *  Function Prototypes
528  */
529 static int ipr_reset_alert(struct ipr_cmnd *);
530 static void ipr_process_ccn(struct ipr_cmnd *);
531 static void ipr_process_error(struct ipr_cmnd *);
532 static void ipr_reset_ioa_job(struct ipr_cmnd *);
533 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
534                                    enum ipr_shutdown_type);
535
536 #ifdef CONFIG_SCSI_IPR_TRACE
537 /**
538  * ipr_trc_hook - Add a trace entry to the driver trace
539  * @ipr_cmd:    ipr command struct
540  * @type:               trace type
541  * @add_data:   additional data
542  *
543  * Return value:
544  *      none
545  **/
546 static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
547                          u8 type, u32 add_data)
548 {
549         struct ipr_trace_entry *trace_entry;
550         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
551
552         trace_entry = &ioa_cfg->trace[ioa_cfg->trace_index++];
553         trace_entry->time = jiffies;
554         trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
555         trace_entry->type = type;
556         if (ipr_cmd->ioa_cfg->sis64)
557                 trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
558         else
559                 trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
560         trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
561         trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
562         trace_entry->u.add_data = add_data;
563 }
564 #else
565 #define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
566 #endif
567
568 /**
569  * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
570  * @ipr_cmd:    ipr command struct
571  *
572  * Return value:
573  *      none
574  **/
575 static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
576 {
577         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
578         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
579         struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
580         dma_addr_t dma_addr = ipr_cmd->dma_addr;
581
582         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
583         ioarcb->data_transfer_length = 0;
584         ioarcb->read_data_transfer_length = 0;
585         ioarcb->ioadl_len = 0;
586         ioarcb->read_ioadl_len = 0;
587
588         if (ipr_cmd->ioa_cfg->sis64) {
589                 ioarcb->u.sis64_addr_data.data_ioadl_addr =
590                         cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
591                 ioasa64->u.gata.status = 0;
592         } else {
593                 ioarcb->write_ioadl_addr =
594                         cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
595                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
596                 ioasa->u.gata.status = 0;
597         }
598
599         ioasa->hdr.ioasc = 0;
600         ioasa->hdr.residual_data_len = 0;
601         ipr_cmd->scsi_cmd = NULL;
602         ipr_cmd->qc = NULL;
603         ipr_cmd->sense_buffer[0] = 0;
604         ipr_cmd->dma_use_sg = 0;
605 }
606
607 /**
608  * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
609  * @ipr_cmd:    ipr command struct
610  *
611  * Return value:
612  *      none
613  **/
614 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
615 {
616         ipr_reinit_ipr_cmnd(ipr_cmd);
617         ipr_cmd->u.scratch = 0;
618         ipr_cmd->sibling = NULL;
619         init_timer(&ipr_cmd->timer);
620 }
621
622 /**
623  * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
624  * @ioa_cfg:    ioa config struct
625  *
626  * Return value:
627  *      pointer to ipr command struct
628  **/
629 static
630 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
631 {
632         struct ipr_cmnd *ipr_cmd;
633
634         ipr_cmd = list_entry(ioa_cfg->free_q.next, struct ipr_cmnd, queue);
635         list_del(&ipr_cmd->queue);
636         ipr_init_ipr_cmnd(ipr_cmd);
637
638         return ipr_cmd;
639 }
640
641 /**
642  * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
643  * @ioa_cfg:    ioa config struct
644  * @clr_ints:     interrupts to clear
645  *
646  * This function masks all interrupts on the adapter, then clears the
647  * interrupts specified in the mask
648  *
649  * Return value:
650  *      none
651  **/
652 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
653                                           u32 clr_ints)
654 {
655         volatile u32 int_reg;
656
657         /* Stop new interrupts */
658         ioa_cfg->allow_interrupts = 0;
659
660         /* Set interrupt mask to stop all new interrupts */
661         if (ioa_cfg->sis64)
662                 writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
663         else
664                 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
665
666         /* Clear any pending interrupts */
667         if (ioa_cfg->sis64)
668                 writel(~0, ioa_cfg->regs.clr_interrupt_reg);
669         writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
670         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
671 }
672
673 /**
674  * ipr_save_pcix_cmd_reg - Save PCI-X command register
675  * @ioa_cfg:    ioa config struct
676  *
677  * Return value:
678  *      0 on success / -EIO on failure
679  **/
680 static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
681 {
682         int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
683
684         if (pcix_cmd_reg == 0)
685                 return 0;
686
687         if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
688                                  &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
689                 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
690                 return -EIO;
691         }
692
693         ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
694         return 0;
695 }
696
697 /**
698  * ipr_set_pcix_cmd_reg - Setup PCI-X command register
699  * @ioa_cfg:    ioa config struct
700  *
701  * Return value:
702  *      0 on success / -EIO on failure
703  **/
704 static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
705 {
706         int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
707
708         if (pcix_cmd_reg) {
709                 if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
710                                           ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
711                         dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
712                         return -EIO;
713                 }
714         }
715
716         return 0;
717 }
718
719 /**
720  * ipr_sata_eh_done - done function for aborted SATA commands
721  * @ipr_cmd:    ipr command struct
722  *
723  * This function is invoked for ops generated to SATA
724  * devices which are being aborted.
725  *
726  * Return value:
727  *      none
728  **/
729 static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
730 {
731         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
732         struct ata_queued_cmd *qc = ipr_cmd->qc;
733         struct ipr_sata_port *sata_port = qc->ap->private_data;
734
735         qc->err_mask |= AC_ERR_OTHER;
736         sata_port->ioasa.status |= ATA_BUSY;
737         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
738         ata_qc_complete(qc);
739 }
740
741 /**
742  * ipr_scsi_eh_done - mid-layer done function for aborted ops
743  * @ipr_cmd:    ipr command struct
744  *
745  * This function is invoked by the interrupt handler for
746  * ops generated by the SCSI mid-layer which are being aborted.
747  *
748  * Return value:
749  *      none
750  **/
751 static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
752 {
753         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
754         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
755
756         scsi_cmd->result |= (DID_ERROR << 16);
757
758         scsi_dma_unmap(ipr_cmd->scsi_cmd);
759         scsi_cmd->scsi_done(scsi_cmd);
760         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
761 }
762
763 /**
764  * ipr_fail_all_ops - Fails all outstanding ops.
765  * @ioa_cfg:    ioa config struct
766  *
767  * This function fails all outstanding ops.
768  *
769  * Return value:
770  *      none
771  **/
772 static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
773 {
774         struct ipr_cmnd *ipr_cmd, *temp;
775
776         ENTER;
777         list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
778                 list_del(&ipr_cmd->queue);
779
780                 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
781                 ipr_cmd->s.ioasa.hdr.ilid = cpu_to_be32(IPR_DRIVER_ILID);
782
783                 if (ipr_cmd->scsi_cmd)
784                         ipr_cmd->done = ipr_scsi_eh_done;
785                 else if (ipr_cmd->qc)
786                         ipr_cmd->done = ipr_sata_eh_done;
787
788                 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, IPR_IOASC_IOA_WAS_RESET);
789                 del_timer(&ipr_cmd->timer);
790                 ipr_cmd->done(ipr_cmd);
791         }
792
793         LEAVE;
794 }
795
796 /**
797  * ipr_send_command -  Send driver initiated requests.
798  * @ipr_cmd:            ipr command struct
799  *
800  * This function sends a command to the adapter using the correct write call.
801  * In the case of sis64, calculate the ioarcb size required. Then or in the
802  * appropriate bits.
803  *
804  * Return value:
805  *      none
806  **/
807 static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
808 {
809         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
810         dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
811
812         if (ioa_cfg->sis64) {
813                 /* The default size is 256 bytes */
814                 send_dma_addr |= 0x1;
815
816                 /* If the number of ioadls * size of ioadl > 128 bytes,
817                    then use a 512 byte ioarcb */
818                 if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
819                         send_dma_addr |= 0x4;
820                 writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
821         } else
822                 writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
823 }
824
825 /**
826  * ipr_do_req -  Send driver initiated requests.
827  * @ipr_cmd:            ipr command struct
828  * @done:                       done function
829  * @timeout_func:       timeout function
830  * @timeout:            timeout value
831  *
832  * This function sends the specified command to the adapter with the
833  * timeout given. The done function is invoked on command completion.
834  *
835  * Return value:
836  *      none
837  **/
838 static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
839                        void (*done) (struct ipr_cmnd *),
840                        void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
841 {
842         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
843
844         list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
845
846         ipr_cmd->done = done;
847
848         ipr_cmd->timer.data = (unsigned long) ipr_cmd;
849         ipr_cmd->timer.expires = jiffies + timeout;
850         ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
851
852         add_timer(&ipr_cmd->timer);
853
854         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
855
856         ipr_send_command(ipr_cmd);
857 }
858
859 /**
860  * ipr_internal_cmd_done - Op done function for an internally generated op.
861  * @ipr_cmd:    ipr command struct
862  *
863  * This function is the op done function for an internally generated,
864  * blocking op. It simply wakes the sleeping thread.
865  *
866  * Return value:
867  *      none
868  **/
869 static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
870 {
871         if (ipr_cmd->sibling)
872                 ipr_cmd->sibling = NULL;
873         else
874                 complete(&ipr_cmd->completion);
875 }
876
877 /**
878  * ipr_init_ioadl - initialize the ioadl for the correct SIS type
879  * @ipr_cmd:    ipr command struct
880  * @dma_addr:   dma address
881  * @len:        transfer length
882  * @flags:      ioadl flag value
883  *
884  * This function initializes an ioadl in the case where there is only a single
885  * descriptor.
886  *
887  * Return value:
888  *      nothing
889  **/
890 static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
891                            u32 len, int flags)
892 {
893         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
894         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
895
896         ipr_cmd->dma_use_sg = 1;
897
898         if (ipr_cmd->ioa_cfg->sis64) {
899                 ioadl64->flags = cpu_to_be32(flags);
900                 ioadl64->data_len = cpu_to_be32(len);
901                 ioadl64->address = cpu_to_be64(dma_addr);
902
903                 ipr_cmd->ioarcb.ioadl_len =
904                         cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
905                 ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
906         } else {
907                 ioadl->flags_and_data_len = cpu_to_be32(flags | len);
908                 ioadl->address = cpu_to_be32(dma_addr);
909
910                 if (flags == IPR_IOADL_FLAGS_READ_LAST) {
911                         ipr_cmd->ioarcb.read_ioadl_len =
912                                 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
913                         ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
914                 } else {
915                         ipr_cmd->ioarcb.ioadl_len =
916                                 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
917                         ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
918                 }
919         }
920 }
921
922 /**
923  * ipr_send_blocking_cmd - Send command and sleep on its completion.
924  * @ipr_cmd:    ipr command struct
925  * @timeout_func:       function to invoke if command times out
926  * @timeout:    timeout
927  *
928  * Return value:
929  *      none
930  **/
931 static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
932                                   void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
933                                   u32 timeout)
934 {
935         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
936
937         init_completion(&ipr_cmd->completion);
938         ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
939
940         spin_unlock_irq(ioa_cfg->host->host_lock);
941         wait_for_completion(&ipr_cmd->completion);
942         spin_lock_irq(ioa_cfg->host->host_lock);
943 }
944
945 /**
946  * ipr_send_hcam - Send an HCAM to the adapter.
947  * @ioa_cfg:    ioa config struct
948  * @type:               HCAM type
949  * @hostrcb:    hostrcb struct
950  *
951  * This function will send a Host Controlled Async command to the adapter.
952  * If HCAMs are currently not allowed to be issued to the adapter, it will
953  * place the hostrcb on the free queue.
954  *
955  * Return value:
956  *      none
957  **/
958 static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
959                           struct ipr_hostrcb *hostrcb)
960 {
961         struct ipr_cmnd *ipr_cmd;
962         struct ipr_ioarcb *ioarcb;
963
964         if (ioa_cfg->allow_cmds) {
965                 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
966                 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
967                 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
968
969                 ipr_cmd->u.hostrcb = hostrcb;
970                 ioarcb = &ipr_cmd->ioarcb;
971
972                 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
973                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
974                 ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
975                 ioarcb->cmd_pkt.cdb[1] = type;
976                 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
977                 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
978
979                 ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
980                                sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
981
982                 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
983                         ipr_cmd->done = ipr_process_ccn;
984                 else
985                         ipr_cmd->done = ipr_process_error;
986
987                 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
988
989                 ipr_send_command(ipr_cmd);
990         } else {
991                 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
992         }
993 }
994
995 /**
996  * ipr_update_ata_class - Update the ata class in the resource entry
997  * @res:        resource entry struct
998  * @proto:      cfgte device bus protocol value
999  *
1000  * Return value:
1001  *      none
1002  **/
1003 static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1004 {
1005         switch (proto) {
1006         case IPR_PROTO_SATA:
1007         case IPR_PROTO_SAS_STP:
1008                 res->ata_class = ATA_DEV_ATA;
1009                 break;
1010         case IPR_PROTO_SATA_ATAPI:
1011         case IPR_PROTO_SAS_STP_ATAPI:
1012                 res->ata_class = ATA_DEV_ATAPI;
1013                 break;
1014         default:
1015                 res->ata_class = ATA_DEV_UNKNOWN;
1016                 break;
1017         };
1018 }
1019
1020 /**
1021  * ipr_init_res_entry - Initialize a resource entry struct.
1022  * @res:        resource entry struct
1023  * @cfgtew:     config table entry wrapper struct
1024  *
1025  * Return value:
1026  *      none
1027  **/
1028 static void ipr_init_res_entry(struct ipr_resource_entry *res,
1029                                struct ipr_config_table_entry_wrapper *cfgtew)
1030 {
1031         int found = 0;
1032         unsigned int proto;
1033         struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1034         struct ipr_resource_entry *gscsi_res = NULL;
1035
1036         res->needs_sync_complete = 0;
1037         res->in_erp = 0;
1038         res->add_to_ml = 0;
1039         res->del_from_ml = 0;
1040         res->resetting_device = 0;
1041         res->sdev = NULL;
1042         res->sata_port = NULL;
1043
1044         if (ioa_cfg->sis64) {
1045                 proto = cfgtew->u.cfgte64->proto;
1046                 res->res_flags = cfgtew->u.cfgte64->res_flags;
1047                 res->qmodel = IPR_QUEUEING_MODEL64(res);
1048                 res->type = cfgtew->u.cfgte64->res_type;
1049
1050                 memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1051                         sizeof(res->res_path));
1052
1053                 res->bus = 0;
1054                 memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1055                         sizeof(res->dev_lun.scsi_lun));
1056                 res->lun = scsilun_to_int(&res->dev_lun);
1057
1058                 if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1059                         list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
1060                                 if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
1061                                         found = 1;
1062                                         res->target = gscsi_res->target;
1063                                         break;
1064                                 }
1065                         }
1066                         if (!found) {
1067                                 res->target = find_first_zero_bit(ioa_cfg->target_ids,
1068                                                                   ioa_cfg->max_devs_supported);
1069                                 set_bit(res->target, ioa_cfg->target_ids);
1070                         }
1071                 } else if (res->type == IPR_RES_TYPE_IOAFP) {
1072                         res->bus = IPR_IOAFP_VIRTUAL_BUS;
1073                         res->target = 0;
1074                 } else if (res->type == IPR_RES_TYPE_ARRAY) {
1075                         res->bus = IPR_ARRAY_VIRTUAL_BUS;
1076                         res->target = find_first_zero_bit(ioa_cfg->array_ids,
1077                                                           ioa_cfg->max_devs_supported);
1078                         set_bit(res->target, ioa_cfg->array_ids);
1079                 } else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
1080                         res->bus = IPR_VSET_VIRTUAL_BUS;
1081                         res->target = find_first_zero_bit(ioa_cfg->vset_ids,
1082                                                           ioa_cfg->max_devs_supported);
1083                         set_bit(res->target, ioa_cfg->vset_ids);
1084                 } else {
1085                         res->target = find_first_zero_bit(ioa_cfg->target_ids,
1086                                                           ioa_cfg->max_devs_supported);
1087                         set_bit(res->target, ioa_cfg->target_ids);
1088                 }
1089         } else {
1090                 proto = cfgtew->u.cfgte->proto;
1091                 res->qmodel = IPR_QUEUEING_MODEL(res);
1092                 res->flags = cfgtew->u.cfgte->flags;
1093                 if (res->flags & IPR_IS_IOA_RESOURCE)
1094                         res->type = IPR_RES_TYPE_IOAFP;
1095                 else
1096                         res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1097
1098                 res->bus = cfgtew->u.cfgte->res_addr.bus;
1099                 res->target = cfgtew->u.cfgte->res_addr.target;
1100                 res->lun = cfgtew->u.cfgte->res_addr.lun;
1101                 res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
1102         }
1103
1104         ipr_update_ata_class(res, proto);
1105 }
1106
1107 /**
1108  * ipr_is_same_device - Determine if two devices are the same.
1109  * @res:        resource entry struct
1110  * @cfgtew:     config table entry wrapper struct
1111  *
1112  * Return value:
1113  *      1 if the devices are the same / 0 otherwise
1114  **/
1115 static int ipr_is_same_device(struct ipr_resource_entry *res,
1116                               struct ipr_config_table_entry_wrapper *cfgtew)
1117 {
1118         if (res->ioa_cfg->sis64) {
1119                 if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
1120                                         sizeof(cfgtew->u.cfgte64->dev_id)) &&
1121                         !memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1122                                         sizeof(cfgtew->u.cfgte64->lun))) {
1123                         return 1;
1124                 }
1125         } else {
1126                 if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
1127                     res->target == cfgtew->u.cfgte->res_addr.target &&
1128                     res->lun == cfgtew->u.cfgte->res_addr.lun)
1129                         return 1;
1130         }
1131
1132         return 0;
1133 }
1134
1135 /**
1136  * ipr_format_res_path - Format the resource path for printing.
1137  * @res_path:   resource path
1138  * @buf:        buffer
1139  *
1140  * Return value:
1141  *      pointer to buffer
1142  **/
1143 static char *ipr_format_res_path(u8 *res_path, char *buffer, int len)
1144 {
1145         int i;
1146         char *p = buffer;
1147
1148         *p = '\0';
1149         p += snprintf(p, buffer + len - p, "%02X", res_path[0]);
1150         for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++)
1151                 p += snprintf(p, buffer + len - p, "-%02X", res_path[i]);
1152
1153         return buffer;
1154 }
1155
1156 /**
1157  * ipr_update_res_entry - Update the resource entry.
1158  * @res:        resource entry struct
1159  * @cfgtew:     config table entry wrapper struct
1160  *
1161  * Return value:
1162  *      none
1163  **/
1164 static void ipr_update_res_entry(struct ipr_resource_entry *res,
1165                                  struct ipr_config_table_entry_wrapper *cfgtew)
1166 {
1167         char buffer[IPR_MAX_RES_PATH_LENGTH];
1168         unsigned int proto;
1169         int new_path = 0;
1170
1171         if (res->ioa_cfg->sis64) {
1172                 res->flags = cfgtew->u.cfgte64->flags;
1173                 res->res_flags = cfgtew->u.cfgte64->res_flags;
1174                 res->type = cfgtew->u.cfgte64->res_type;
1175
1176                 memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1177                         sizeof(struct ipr_std_inq_data));
1178
1179                 res->qmodel = IPR_QUEUEING_MODEL64(res);
1180                 proto = cfgtew->u.cfgte64->proto;
1181                 res->res_handle = cfgtew->u.cfgte64->res_handle;
1182                 res->dev_id = cfgtew->u.cfgte64->dev_id;
1183
1184                 memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1185                         sizeof(res->dev_lun.scsi_lun));
1186
1187                 if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
1188                                         sizeof(res->res_path))) {
1189                         memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1190                                 sizeof(res->res_path));
1191                         new_path = 1;
1192                 }
1193
1194                 if (res->sdev && new_path)
1195                         sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
1196                                     ipr_format_res_path(res->res_path, buffer,
1197                                                         sizeof(buffer)));
1198         } else {
1199                 res->flags = cfgtew->u.cfgte->flags;
1200                 if (res->flags & IPR_IS_IOA_RESOURCE)
1201                         res->type = IPR_RES_TYPE_IOAFP;
1202                 else
1203                         res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1204
1205                 memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1206                         sizeof(struct ipr_std_inq_data));
1207
1208                 res->qmodel = IPR_QUEUEING_MODEL(res);
1209                 proto = cfgtew->u.cfgte->proto;
1210                 res->res_handle = cfgtew->u.cfgte->res_handle;
1211         }
1212
1213         ipr_update_ata_class(res, proto);
1214 }
1215
1216 /**
1217  * ipr_clear_res_target - Clear the bit in the bit map representing the target
1218  *                        for the resource.
1219  * @res:        resource entry struct
1220  * @cfgtew:     config table entry wrapper struct
1221  *
1222  * Return value:
1223  *      none
1224  **/
1225 static void ipr_clear_res_target(struct ipr_resource_entry *res)
1226 {
1227         struct ipr_resource_entry *gscsi_res = NULL;
1228         struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1229
1230         if (!ioa_cfg->sis64)
1231                 return;
1232
1233         if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
1234                 clear_bit(res->target, ioa_cfg->array_ids);
1235         else if (res->bus == IPR_VSET_VIRTUAL_BUS)
1236                 clear_bit(res->target, ioa_cfg->vset_ids);
1237         else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1238                 list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
1239                         if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
1240                                 return;
1241                 clear_bit(res->target, ioa_cfg->target_ids);
1242
1243         } else if (res->bus == 0)
1244                 clear_bit(res->target, ioa_cfg->target_ids);
1245 }
1246
1247 /**
1248  * ipr_handle_config_change - Handle a config change from the adapter
1249  * @ioa_cfg:    ioa config struct
1250  * @hostrcb:    hostrcb
1251  *
1252  * Return value:
1253  *      none
1254  **/
1255 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1256                                      struct ipr_hostrcb *hostrcb)
1257 {
1258         struct ipr_resource_entry *res = NULL;
1259         struct ipr_config_table_entry_wrapper cfgtew;
1260         __be32 cc_res_handle;
1261
1262         u32 is_ndn = 1;
1263
1264         if (ioa_cfg->sis64) {
1265                 cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1266                 cc_res_handle = cfgtew.u.cfgte64->res_handle;
1267         } else {
1268                 cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1269                 cc_res_handle = cfgtew.u.cfgte->res_handle;
1270         }
1271
1272         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1273                 if (res->res_handle == cc_res_handle) {
1274                         is_ndn = 0;
1275                         break;
1276                 }
1277         }
1278
1279         if (is_ndn) {
1280                 if (list_empty(&ioa_cfg->free_res_q)) {
1281                         ipr_send_hcam(ioa_cfg,
1282                                       IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1283                                       hostrcb);
1284                         return;
1285                 }
1286
1287                 res = list_entry(ioa_cfg->free_res_q.next,
1288                                  struct ipr_resource_entry, queue);
1289
1290                 list_del(&res->queue);
1291                 ipr_init_res_entry(res, &cfgtew);
1292                 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1293         }
1294
1295         ipr_update_res_entry(res, &cfgtew);
1296
1297         if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1298                 if (res->sdev) {
1299                         res->del_from_ml = 1;
1300                         res->res_handle = IPR_INVALID_RES_HANDLE;
1301                         if (ioa_cfg->allow_ml_add_del)
1302                                 schedule_work(&ioa_cfg->work_q);
1303                 } else {
1304                         ipr_clear_res_target(res);
1305                         list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1306                 }
1307         } else if (!res->sdev || res->del_from_ml) {
1308                 res->add_to_ml = 1;
1309                 if (ioa_cfg->allow_ml_add_del)
1310                         schedule_work(&ioa_cfg->work_q);
1311         }
1312
1313         ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1314 }
1315
1316 /**
1317  * ipr_process_ccn - Op done function for a CCN.
1318  * @ipr_cmd:    ipr command struct
1319  *
1320  * This function is the op done function for a configuration
1321  * change notification host controlled async from the adapter.
1322  *
1323  * Return value:
1324  *      none
1325  **/
1326 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
1327 {
1328         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1329         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1330         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
1331
1332         list_del(&hostrcb->queue);
1333         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
1334
1335         if (ioasc) {
1336                 if (ioasc != IPR_IOASC_IOA_WAS_RESET)
1337                         dev_err(&ioa_cfg->pdev->dev,
1338                                 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1339
1340                 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1341         } else {
1342                 ipr_handle_config_change(ioa_cfg, hostrcb);
1343         }
1344 }
1345
1346 /**
1347  * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1348  * @i:          index into buffer
1349  * @buf:                string to modify
1350  *
1351  * This function will strip all trailing whitespace, pad the end
1352  * of the string with a single space, and NULL terminate the string.
1353  *
1354  * Return value:
1355  *      new length of string
1356  **/
1357 static int strip_and_pad_whitespace(int i, char *buf)
1358 {
1359         while (i && buf[i] == ' ')
1360                 i--;
1361         buf[i+1] = ' ';
1362         buf[i+2] = '\0';
1363         return i + 2;
1364 }
1365
1366 /**
1367  * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1368  * @prefix:             string to print at start of printk
1369  * @hostrcb:    hostrcb pointer
1370  * @vpd:                vendor/product id/sn struct
1371  *
1372  * Return value:
1373  *      none
1374  **/
1375 static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1376                                 struct ipr_vpd *vpd)
1377 {
1378         char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
1379         int i = 0;
1380
1381         memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1382         i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
1383
1384         memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
1385         i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
1386
1387         memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
1388         buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
1389
1390         ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
1391 }
1392
1393 /**
1394  * ipr_log_vpd - Log the passed VPD to the error log.
1395  * @vpd:                vendor/product id/sn struct
1396  *
1397  * Return value:
1398  *      none
1399  **/
1400 static void ipr_log_vpd(struct ipr_vpd *vpd)
1401 {
1402         char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1403                     + IPR_SERIAL_NUM_LEN];
1404
1405         memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1406         memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1407                IPR_PROD_ID_LEN);
1408         buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1409         ipr_err("Vendor/Product ID: %s\n", buffer);
1410
1411         memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1412         buffer[IPR_SERIAL_NUM_LEN] = '\0';
1413         ipr_err("    Serial Number: %s\n", buffer);
1414 }
1415
1416 /**
1417  * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1418  * @prefix:             string to print at start of printk
1419  * @hostrcb:    hostrcb pointer
1420  * @vpd:                vendor/product id/sn/wwn struct
1421  *
1422  * Return value:
1423  *      none
1424  **/
1425 static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1426                                     struct ipr_ext_vpd *vpd)
1427 {
1428         ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1429         ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1430                      be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1431 }
1432
1433 /**
1434  * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1435  * @vpd:                vendor/product id/sn/wwn struct
1436  *
1437  * Return value:
1438  *      none
1439  **/
1440 static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1441 {
1442         ipr_log_vpd(&vpd->vpd);
1443         ipr_err("    WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1444                 be32_to_cpu(vpd->wwid[1]));
1445 }
1446
1447 /**
1448  * ipr_log_enhanced_cache_error - Log a cache error.
1449  * @ioa_cfg:    ioa config struct
1450  * @hostrcb:    hostrcb struct
1451  *
1452  * Return value:
1453  *      none
1454  **/
1455 static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1456                                          struct ipr_hostrcb *hostrcb)
1457 {
1458         struct ipr_hostrcb_type_12_error *error;
1459
1460         if (ioa_cfg->sis64)
1461                 error = &hostrcb->hcam.u.error64.u.type_12_error;
1462         else
1463                 error = &hostrcb->hcam.u.error.u.type_12_error;
1464
1465         ipr_err("-----Current Configuration-----\n");
1466         ipr_err("Cache Directory Card Information:\n");
1467         ipr_log_ext_vpd(&error->ioa_vpd);
1468         ipr_err("Adapter Card Information:\n");
1469         ipr_log_ext_vpd(&error->cfc_vpd);
1470
1471         ipr_err("-----Expected Configuration-----\n");
1472         ipr_err("Cache Directory Card Information:\n");
1473         ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1474         ipr_err("Adapter Card Information:\n");
1475         ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1476
1477         ipr_err("Additional IOA Data: %08X %08X %08X\n",
1478                      be32_to_cpu(error->ioa_data[0]),
1479                      be32_to_cpu(error->ioa_data[1]),
1480                      be32_to_cpu(error->ioa_data[2]));
1481 }
1482
1483 /**
1484  * ipr_log_cache_error - Log a cache error.
1485  * @ioa_cfg:    ioa config struct
1486  * @hostrcb:    hostrcb struct
1487  *
1488  * Return value:
1489  *      none
1490  **/
1491 static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1492                                 struct ipr_hostrcb *hostrcb)
1493 {
1494         struct ipr_hostrcb_type_02_error *error =
1495                 &hostrcb->hcam.u.error.u.type_02_error;
1496
1497         ipr_err("-----Current Configuration-----\n");
1498         ipr_err("Cache Directory Card Information:\n");
1499         ipr_log_vpd(&error->ioa_vpd);
1500         ipr_err("Adapter Card Information:\n");
1501         ipr_log_vpd(&error->cfc_vpd);
1502
1503         ipr_err("-----Expected Configuration-----\n");
1504         ipr_err("Cache Directory Card Information:\n");
1505         ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1506         ipr_err("Adapter Card Information:\n");
1507         ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1508
1509         ipr_err("Additional IOA Data: %08X %08X %08X\n",
1510                      be32_to_cpu(error->ioa_data[0]),
1511                      be32_to_cpu(error->ioa_data[1]),
1512                      be32_to_cpu(error->ioa_data[2]));
1513 }
1514
1515 /**
1516  * ipr_log_enhanced_config_error - Log a configuration error.
1517  * @ioa_cfg:    ioa config struct
1518  * @hostrcb:    hostrcb struct
1519  *
1520  * Return value:
1521  *      none
1522  **/
1523 static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1524                                           struct ipr_hostrcb *hostrcb)
1525 {
1526         int errors_logged, i;
1527         struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1528         struct ipr_hostrcb_type_13_error *error;
1529
1530         error = &hostrcb->hcam.u.error.u.type_13_error;
1531         errors_logged = be32_to_cpu(error->errors_logged);
1532
1533         ipr_err("Device Errors Detected/Logged: %d/%d\n",
1534                 be32_to_cpu(error->errors_detected), errors_logged);
1535
1536         dev_entry = error->dev;
1537
1538         for (i = 0; i < errors_logged; i++, dev_entry++) {
1539                 ipr_err_separator;
1540
1541                 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1542                 ipr_log_ext_vpd(&dev_entry->vpd);
1543
1544                 ipr_err("-----New Device Information-----\n");
1545                 ipr_log_ext_vpd(&dev_entry->new_vpd);
1546
1547                 ipr_err("Cache Directory Card Information:\n");
1548                 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1549
1550                 ipr_err("Adapter Card Information:\n");
1551                 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1552         }
1553 }
1554
1555 /**
1556  * ipr_log_sis64_config_error - Log a device error.
1557  * @ioa_cfg:    ioa config struct
1558  * @hostrcb:    hostrcb struct
1559  *
1560  * Return value:
1561  *      none
1562  **/
1563 static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1564                                        struct ipr_hostrcb *hostrcb)
1565 {
1566         int errors_logged, i;
1567         struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1568         struct ipr_hostrcb_type_23_error *error;
1569         char buffer[IPR_MAX_RES_PATH_LENGTH];
1570
1571         error = &hostrcb->hcam.u.error64.u.type_23_error;
1572         errors_logged = be32_to_cpu(error->errors_logged);
1573
1574         ipr_err("Device Errors Detected/Logged: %d/%d\n",
1575                 be32_to_cpu(error->errors_detected), errors_logged);
1576
1577         dev_entry = error->dev;
1578
1579         for (i = 0; i < errors_logged; i++, dev_entry++) {
1580                 ipr_err_separator;
1581
1582                 ipr_err("Device %d : %s", i + 1,
1583                          ipr_format_res_path(dev_entry->res_path, buffer,
1584                                              sizeof(buffer)));
1585                 ipr_log_ext_vpd(&dev_entry->vpd);
1586
1587                 ipr_err("-----New Device Information-----\n");
1588                 ipr_log_ext_vpd(&dev_entry->new_vpd);
1589
1590                 ipr_err("Cache Directory Card Information:\n");
1591                 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1592
1593                 ipr_err("Adapter Card Information:\n");
1594                 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1595         }
1596 }
1597
1598 /**
1599  * ipr_log_config_error - Log a configuration error.
1600  * @ioa_cfg:    ioa config struct
1601  * @hostrcb:    hostrcb struct
1602  *
1603  * Return value:
1604  *      none
1605  **/
1606 static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1607                                  struct ipr_hostrcb *hostrcb)
1608 {
1609         int errors_logged, i;
1610         struct ipr_hostrcb_device_data_entry *dev_entry;
1611         struct ipr_hostrcb_type_03_error *error;
1612
1613         error = &hostrcb->hcam.u.error.u.type_03_error;
1614         errors_logged = be32_to_cpu(error->errors_logged);
1615
1616         ipr_err("Device Errors Detected/Logged: %d/%d\n",
1617                 be32_to_cpu(error->errors_detected), errors_logged);
1618
1619         dev_entry = error->dev;
1620
1621         for (i = 0; i < errors_logged; i++, dev_entry++) {
1622                 ipr_err_separator;
1623
1624                 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1625                 ipr_log_vpd(&dev_entry->vpd);
1626
1627                 ipr_err("-----New Device Information-----\n");
1628                 ipr_log_vpd(&dev_entry->new_vpd);
1629
1630                 ipr_err("Cache Directory Card Information:\n");
1631                 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1632
1633                 ipr_err("Adapter Card Information:\n");
1634                 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1635
1636                 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1637                         be32_to_cpu(dev_entry->ioa_data[0]),
1638                         be32_to_cpu(dev_entry->ioa_data[1]),
1639                         be32_to_cpu(dev_entry->ioa_data[2]),
1640                         be32_to_cpu(dev_entry->ioa_data[3]),
1641                         be32_to_cpu(dev_entry->ioa_data[4]));
1642         }
1643 }
1644
1645 /**
1646  * ipr_log_enhanced_array_error - Log an array configuration error.
1647  * @ioa_cfg:    ioa config struct
1648  * @hostrcb:    hostrcb struct
1649  *
1650  * Return value:
1651  *      none
1652  **/
1653 static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1654                                          struct ipr_hostrcb *hostrcb)
1655 {
1656         int i, num_entries;
1657         struct ipr_hostrcb_type_14_error *error;
1658         struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1659         const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1660
1661         error = &hostrcb->hcam.u.error.u.type_14_error;
1662
1663         ipr_err_separator;
1664
1665         ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1666                 error->protection_level,
1667                 ioa_cfg->host->host_no,
1668                 error->last_func_vset_res_addr.bus,
1669                 error->last_func_vset_res_addr.target,
1670                 error->last_func_vset_res_addr.lun);
1671
1672         ipr_err_separator;
1673
1674         array_entry = error->array_member;
1675         num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1676                             ARRAY_SIZE(error->array_member));
1677
1678         for (i = 0; i < num_entries; i++, array_entry++) {
1679                 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1680                         continue;
1681
1682                 if (be32_to_cpu(error->exposed_mode_adn) == i)
1683                         ipr_err("Exposed Array Member %d:\n", i);
1684                 else
1685                         ipr_err("Array Member %d:\n", i);
1686
1687                 ipr_log_ext_vpd(&array_entry->vpd);
1688                 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1689                 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1690                                  "Expected Location");
1691
1692                 ipr_err_separator;
1693         }
1694 }
1695
1696 /**
1697  * ipr_log_array_error - Log an array configuration error.
1698  * @ioa_cfg:    ioa config struct
1699  * @hostrcb:    hostrcb struct
1700  *
1701  * Return value:
1702  *      none
1703  **/
1704 static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1705                                 struct ipr_hostrcb *hostrcb)
1706 {
1707         int i;
1708         struct ipr_hostrcb_type_04_error *error;
1709         struct ipr_hostrcb_array_data_entry *array_entry;
1710         const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1711
1712         error = &hostrcb->hcam.u.error.u.type_04_error;
1713
1714         ipr_err_separator;
1715
1716         ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1717                 error->protection_level,
1718                 ioa_cfg->host->host_no,
1719                 error->last_func_vset_res_addr.bus,
1720                 error->last_func_vset_res_addr.target,
1721                 error->last_func_vset_res_addr.lun);
1722
1723         ipr_err_separator;
1724
1725         array_entry = error->array_member;
1726
1727         for (i = 0; i < 18; i++) {
1728                 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1729                         continue;
1730
1731                 if (be32_to_cpu(error->exposed_mode_adn) == i)
1732                         ipr_err("Exposed Array Member %d:\n", i);
1733                 else
1734                         ipr_err("Array Member %d:\n", i);
1735
1736                 ipr_log_vpd(&array_entry->vpd);
1737
1738                 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1739                 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1740                                  "Expected Location");
1741
1742                 ipr_err_separator;
1743
1744                 if (i == 9)
1745                         array_entry = error->array_member2;
1746                 else
1747                         array_entry++;
1748         }
1749 }
1750
1751 /**
1752  * ipr_log_hex_data - Log additional hex IOA error data.
1753  * @ioa_cfg:    ioa config struct
1754  * @data:               IOA error data
1755  * @len:                data length
1756  *
1757  * Return value:
1758  *      none
1759  **/
1760 static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, u32 *data, int len)
1761 {
1762         int i;
1763
1764         if (len == 0)
1765                 return;
1766
1767         if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1768                 len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1769
1770         for (i = 0; i < len / 4; i += 4) {
1771                 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1772                         be32_to_cpu(data[i]),
1773                         be32_to_cpu(data[i+1]),
1774                         be32_to_cpu(data[i+2]),
1775                         be32_to_cpu(data[i+3]));
1776         }
1777 }
1778
1779 /**
1780  * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1781  * @ioa_cfg:    ioa config struct
1782  * @hostrcb:    hostrcb struct
1783  *
1784  * Return value:
1785  *      none
1786  **/
1787 static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1788                                             struct ipr_hostrcb *hostrcb)
1789 {
1790         struct ipr_hostrcb_type_17_error *error;
1791
1792         if (ioa_cfg->sis64)
1793                 error = &hostrcb->hcam.u.error64.u.type_17_error;
1794         else
1795                 error = &hostrcb->hcam.u.error.u.type_17_error;
1796
1797         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1798         strim(error->failure_reason);
1799
1800         ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1801                      be32_to_cpu(hostrcb->hcam.u.error.prc));
1802         ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1803         ipr_log_hex_data(ioa_cfg, error->data,
1804                          be32_to_cpu(hostrcb->hcam.length) -
1805                          (offsetof(struct ipr_hostrcb_error, u) +
1806                           offsetof(struct ipr_hostrcb_type_17_error, data)));
1807 }
1808
1809 /**
1810  * ipr_log_dual_ioa_error - Log a dual adapter error.
1811  * @ioa_cfg:    ioa config struct
1812  * @hostrcb:    hostrcb struct
1813  *
1814  * Return value:
1815  *      none
1816  **/
1817 static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1818                                    struct ipr_hostrcb *hostrcb)
1819 {
1820         struct ipr_hostrcb_type_07_error *error;
1821
1822         error = &hostrcb->hcam.u.error.u.type_07_error;
1823         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1824         strim(error->failure_reason);
1825
1826         ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1827                      be32_to_cpu(hostrcb->hcam.u.error.prc));
1828         ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1829         ipr_log_hex_data(ioa_cfg, error->data,
1830                          be32_to_cpu(hostrcb->hcam.length) -
1831                          (offsetof(struct ipr_hostrcb_error, u) +
1832                           offsetof(struct ipr_hostrcb_type_07_error, data)));
1833 }
1834
1835 static const struct {
1836         u8 active;
1837         char *desc;
1838 } path_active_desc[] = {
1839         { IPR_PATH_NO_INFO, "Path" },
1840         { IPR_PATH_ACTIVE, "Active path" },
1841         { IPR_PATH_NOT_ACTIVE, "Inactive path" }
1842 };
1843
1844 static const struct {
1845         u8 state;
1846         char *desc;
1847 } path_state_desc[] = {
1848         { IPR_PATH_STATE_NO_INFO, "has no path state information available" },
1849         { IPR_PATH_HEALTHY, "is healthy" },
1850         { IPR_PATH_DEGRADED, "is degraded" },
1851         { IPR_PATH_FAILED, "is failed" }
1852 };
1853
1854 /**
1855  * ipr_log_fabric_path - Log a fabric path error
1856  * @hostrcb:    hostrcb struct
1857  * @fabric:             fabric descriptor
1858  *
1859  * Return value:
1860  *      none
1861  **/
1862 static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
1863                                 struct ipr_hostrcb_fabric_desc *fabric)
1864 {
1865         int i, j;
1866         u8 path_state = fabric->path_state;
1867         u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1868         u8 state = path_state & IPR_PATH_STATE_MASK;
1869
1870         for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1871                 if (path_active_desc[i].active != active)
1872                         continue;
1873
1874                 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1875                         if (path_state_desc[j].state != state)
1876                                 continue;
1877
1878                         if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
1879                                 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
1880                                              path_active_desc[i].desc, path_state_desc[j].desc,
1881                                              fabric->ioa_port);
1882                         } else if (fabric->cascaded_expander == 0xff) {
1883                                 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
1884                                              path_active_desc[i].desc, path_state_desc[j].desc,
1885                                              fabric->ioa_port, fabric->phy);
1886                         } else if (fabric->phy == 0xff) {
1887                                 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
1888                                              path_active_desc[i].desc, path_state_desc[j].desc,
1889                                              fabric->ioa_port, fabric->cascaded_expander);
1890                         } else {
1891                                 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
1892                                              path_active_desc[i].desc, path_state_desc[j].desc,
1893                                              fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1894                         }
1895                         return;
1896                 }
1897         }
1898
1899         ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
1900                 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1901 }
1902
1903 /**
1904  * ipr_log64_fabric_path - Log a fabric path error
1905  * @hostrcb:    hostrcb struct
1906  * @fabric:             fabric descriptor
1907  *
1908  * Return value:
1909  *      none
1910  **/
1911 static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
1912                                   struct ipr_hostrcb64_fabric_desc *fabric)
1913 {
1914         int i, j;
1915         u8 path_state = fabric->path_state;
1916         u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1917         u8 state = path_state & IPR_PATH_STATE_MASK;
1918         char buffer[IPR_MAX_RES_PATH_LENGTH];
1919
1920         for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1921                 if (path_active_desc[i].active != active)
1922                         continue;
1923
1924                 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1925                         if (path_state_desc[j].state != state)
1926                                 continue;
1927
1928                         ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
1929                                      path_active_desc[i].desc, path_state_desc[j].desc,
1930                                      ipr_format_res_path(fabric->res_path, buffer,
1931                                                          sizeof(buffer)));
1932                         return;
1933                 }
1934         }
1935
1936         ipr_err("Path state=%02X Resource Path=%s\n", path_state,
1937                 ipr_format_res_path(fabric->res_path, buffer, sizeof(buffer)));
1938 }
1939
1940 static const struct {
1941         u8 type;
1942         char *desc;
1943 } path_type_desc[] = {
1944         { IPR_PATH_CFG_IOA_PORT, "IOA port" },
1945         { IPR_PATH_CFG_EXP_PORT, "Expander port" },
1946         { IPR_PATH_CFG_DEVICE_PORT, "Device port" },
1947         { IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
1948 };
1949
1950 static const struct {
1951         u8 status;
1952         char *desc;
1953 } path_status_desc[] = {
1954         { IPR_PATH_CFG_NO_PROB, "Functional" },
1955         { IPR_PATH_CFG_DEGRADED, "Degraded" },
1956         { IPR_PATH_CFG_FAILED, "Failed" },
1957         { IPR_PATH_CFG_SUSPECT, "Suspect" },
1958         { IPR_PATH_NOT_DETECTED, "Missing" },
1959         { IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
1960 };
1961
1962 static const char *link_rate[] = {
1963         "unknown",
1964         "disabled",
1965         "phy reset problem",
1966         "spinup hold",
1967         "port selector",
1968         "unknown",
1969         "unknown",
1970         "unknown",
1971         "1.5Gbps",
1972         "3.0Gbps",
1973         "unknown",
1974         "unknown",
1975         "unknown",
1976         "unknown",
1977         "unknown",
1978         "unknown"
1979 };
1980
1981 /**
1982  * ipr_log_path_elem - Log a fabric path element.
1983  * @hostrcb:    hostrcb struct
1984  * @cfg:                fabric path element struct
1985  *
1986  * Return value:
1987  *      none
1988  **/
1989 static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
1990                               struct ipr_hostrcb_config_element *cfg)
1991 {
1992         int i, j;
1993         u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
1994         u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
1995
1996         if (type == IPR_PATH_CFG_NOT_EXIST)
1997                 return;
1998
1999         for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2000                 if (path_type_desc[i].type != type)
2001                         continue;
2002
2003                 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2004                         if (path_status_desc[j].status != status)
2005                                 continue;
2006
2007                         if (type == IPR_PATH_CFG_IOA_PORT) {
2008                                 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2009                                              path_status_desc[j].desc, path_type_desc[i].desc,
2010                                              cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2011                                              be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2012                         } else {
2013                                 if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2014                                         ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2015                                                      path_status_desc[j].desc, path_type_desc[i].desc,
2016                                                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2017                                                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2018                                 } else if (cfg->cascaded_expander == 0xff) {
2019                                         ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2020                                                      "WWN=%08X%08X\n", path_status_desc[j].desc,
2021                                                      path_type_desc[i].desc, cfg->phy,
2022                                                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2023                                                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2024                                 } else if (cfg->phy == 0xff) {
2025                                         ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2026                                                      "WWN=%08X%08X\n", path_status_desc[j].desc,
2027                                                      path_type_desc[i].desc, cfg->cascaded_expander,
2028                                                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2029                                                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2030                                 } else {
2031                                         ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2032                                                      "WWN=%08X%08X\n", path_status_desc[j].desc,
2033                                                      path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2034                                                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2035                                                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2036                                 }
2037                         }
2038                         return;
2039                 }
2040         }
2041
2042         ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2043                      "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2044                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2045                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2046 }
2047
2048 /**
2049  * ipr_log64_path_elem - Log a fabric path element.
2050  * @hostrcb:    hostrcb struct
2051  * @cfg:                fabric path element struct
2052  *
2053  * Return value:
2054  *      none
2055  **/
2056 static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2057                                 struct ipr_hostrcb64_config_element *cfg)
2058 {
2059         int i, j;
2060         u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2061         u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2062         u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2063         char buffer[IPR_MAX_RES_PATH_LENGTH];
2064
2065         if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2066                 return;
2067
2068         for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2069                 if (path_type_desc[i].type != type)
2070                         continue;
2071
2072                 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2073                         if (path_status_desc[j].status != status)
2074                                 continue;
2075
2076                         ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2077                                      path_status_desc[j].desc, path_type_desc[i].desc,
2078                                      ipr_format_res_path(cfg->res_path, buffer,
2079                                                          sizeof(buffer)),
2080                                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2081                                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2082                         return;
2083                 }
2084         }
2085         ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2086                      "WWN=%08X%08X\n", cfg->type_status,
2087                      ipr_format_res_path(cfg->res_path, buffer, sizeof(buffer)),
2088                      link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2089                      be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2090 }
2091
2092 /**
2093  * ipr_log_fabric_error - Log a fabric error.
2094  * @ioa_cfg:    ioa config struct
2095  * @hostrcb:    hostrcb struct
2096  *
2097  * Return value:
2098  *      none
2099  **/
2100 static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2101                                  struct ipr_hostrcb *hostrcb)
2102 {
2103         struct ipr_hostrcb_type_20_error *error;
2104         struct ipr_hostrcb_fabric_desc *fabric;
2105         struct ipr_hostrcb_config_element *cfg;
2106         int i, add_len;
2107
2108         error = &hostrcb->hcam.u.error.u.type_20_error;
2109         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2110         ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2111
2112         add_len = be32_to_cpu(hostrcb->hcam.length) -
2113                 (offsetof(struct ipr_hostrcb_error, u) +
2114                  offsetof(struct ipr_hostrcb_type_20_error, desc));
2115
2116         for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2117                 ipr_log_fabric_path(hostrcb, fabric);
2118                 for_each_fabric_cfg(fabric, cfg)
2119                         ipr_log_path_elem(hostrcb, cfg);
2120
2121                 add_len -= be16_to_cpu(fabric->length);
2122                 fabric = (struct ipr_hostrcb_fabric_desc *)
2123                         ((unsigned long)fabric + be16_to_cpu(fabric->length));
2124         }
2125
2126         ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2127 }
2128
2129 /**
2130  * ipr_log_sis64_array_error - Log a sis64 array error.
2131  * @ioa_cfg:    ioa config struct
2132  * @hostrcb:    hostrcb struct
2133  *
2134  * Return value:
2135  *      none
2136  **/
2137 static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2138                                       struct ipr_hostrcb *hostrcb)
2139 {
2140         int i, num_entries;
2141         struct ipr_hostrcb_type_24_error *error;
2142         struct ipr_hostrcb64_array_data_entry *array_entry;
2143         char buffer[IPR_MAX_RES_PATH_LENGTH];
2144         const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2145
2146         error = &hostrcb->hcam.u.error64.u.type_24_error;
2147
2148         ipr_err_separator;
2149
2150         ipr_err("RAID %s Array Configuration: %s\n",
2151                 error->protection_level,
2152                 ipr_format_res_path(error->last_res_path, buffer, sizeof(buffer)));
2153
2154         ipr_err_separator;
2155
2156         array_entry = error->array_member;
2157         num_entries = min_t(u32, error->num_entries,
2158                             ARRAY_SIZE(error->array_member));
2159
2160         for (i = 0; i < num_entries; i++, array_entry++) {
2161
2162                 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2163                         continue;
2164
2165                 if (error->exposed_mode_adn == i)
2166                         ipr_err("Exposed Array Member %d:\n", i);
2167                 else
2168                         ipr_err("Array Member %d:\n", i);
2169
2170                 ipr_err("Array Member %d:\n", i);
2171                 ipr_log_ext_vpd(&array_entry->vpd);
2172                 ipr_err("Current Location: %s\n",
2173                          ipr_format_res_path(array_entry->res_path, buffer,
2174                                              sizeof(buffer)));
2175                 ipr_err("Expected Location: %s\n",
2176                          ipr_format_res_path(array_entry->expected_res_path,
2177                                              buffer, sizeof(buffer)));
2178
2179                 ipr_err_separator;
2180         }
2181 }
2182
2183 /**
2184  * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2185  * @ioa_cfg:    ioa config struct
2186  * @hostrcb:    hostrcb struct
2187  *
2188  * Return value:
2189  *      none
2190  **/
2191 static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2192                                        struct ipr_hostrcb *hostrcb)
2193 {
2194         struct ipr_hostrcb_type_30_error *error;
2195         struct ipr_hostrcb64_fabric_desc *fabric;
2196         struct ipr_hostrcb64_config_element *cfg;
2197         int i, add_len;
2198
2199         error = &hostrcb->hcam.u.error64.u.type_30_error;
2200
2201         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2202         ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2203
2204         add_len = be32_to_cpu(hostrcb->hcam.length) -
2205                 (offsetof(struct ipr_hostrcb64_error, u) +
2206                  offsetof(struct ipr_hostrcb_type_30_error, desc));
2207
2208         for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2209                 ipr_log64_fabric_path(hostrcb, fabric);
2210                 for_each_fabric_cfg(fabric, cfg)
2211                         ipr_log64_path_elem(hostrcb, cfg);
2212
2213                 add_len -= be16_to_cpu(fabric->length);
2214                 fabric = (struct ipr_hostrcb64_fabric_desc *)
2215                         ((unsigned long)fabric + be16_to_cpu(fabric->length));
2216         }
2217
2218         ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2219 }
2220
2221 /**
2222  * ipr_log_generic_error - Log an adapter error.
2223  * @ioa_cfg:    ioa config struct
2224  * @hostrcb:    hostrcb struct
2225  *
2226  * Return value:
2227  *      none
2228  **/
2229 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2230                                   struct ipr_hostrcb *hostrcb)
2231 {
2232         ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2233                          be32_to_cpu(hostrcb->hcam.length));
2234 }
2235
2236 /**
2237  * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2238  * @ioasc:      IOASC
2239  *
2240  * This function will return the index of into the ipr_error_table
2241  * for the specified IOASC. If the IOASC is not in the table,
2242  * 0 will be returned, which points to the entry used for unknown errors.
2243  *
2244  * Return value:
2245  *      index into the ipr_error_table
2246  **/
2247 static u32 ipr_get_error(u32 ioasc)
2248 {
2249         int i;
2250
2251         for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2252                 if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2253                         return i;
2254
2255         return 0;
2256 }
2257
2258 /**
2259  * ipr_handle_log_data - Log an adapter error.
2260  * @ioa_cfg:    ioa config struct
2261  * @hostrcb:    hostrcb struct
2262  *
2263  * This function logs an adapter error to the system.
2264  *
2265  * Return value:
2266  *      none
2267  **/
2268 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2269                                 struct ipr_hostrcb *hostrcb)
2270 {
2271         u32 ioasc;
2272         int error_index;
2273
2274         if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2275                 return;
2276
2277         if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2278                 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2279
2280         if (ioa_cfg->sis64)
2281                 ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2282         else
2283                 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2284
2285         if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2286             ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2287                 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2288                 scsi_report_bus_reset(ioa_cfg->host,
2289                                       hostrcb->hcam.u.error.fd_res_addr.bus);
2290         }
2291
2292         error_index = ipr_get_error(ioasc);
2293
2294         if (!ipr_error_table[error_index].log_hcam)
2295                 return;
2296
2297         ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2298
2299         /* Set indication we have logged an error */
2300         ioa_cfg->errors_logged++;
2301
2302         if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2303                 return;
2304         if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2305                 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2306
2307         switch (hostrcb->hcam.overlay_id) {
2308         case IPR_HOST_RCB_OVERLAY_ID_2:
2309                 ipr_log_cache_error(ioa_cfg, hostrcb);
2310                 break;
2311         case IPR_HOST_RCB_OVERLAY_ID_3:
2312                 ipr_log_config_error(ioa_cfg, hostrcb);
2313                 break;
2314         case IPR_HOST_RCB_OVERLAY_ID_4:
2315         case IPR_HOST_RCB_OVERLAY_ID_6:
2316                 ipr_log_array_error(ioa_cfg, hostrcb);
2317                 break;
2318         case IPR_HOST_RCB_OVERLAY_ID_7:
2319                 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2320                 break;
2321         case IPR_HOST_RCB_OVERLAY_ID_12:
2322                 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2323                 break;
2324         case IPR_HOST_RCB_OVERLAY_ID_13:
2325                 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2326                 break;
2327         case IPR_HOST_RCB_OVERLAY_ID_14:
2328         case IPR_HOST_RCB_OVERLAY_ID_16:
2329                 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2330                 break;
2331         case IPR_HOST_RCB_OVERLAY_ID_17:
2332                 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2333                 break;
2334         case IPR_HOST_RCB_OVERLAY_ID_20:
2335                 ipr_log_fabric_error(ioa_cfg, hostrcb);
2336                 break;
2337         case IPR_HOST_RCB_OVERLAY_ID_23:
2338                 ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2339                 break;
2340         case IPR_HOST_RCB_OVERLAY_ID_24:
2341         case IPR_HOST_RCB_OVERLAY_ID_26:
2342                 ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2343                 break;
2344         case IPR_HOST_RCB_OVERLAY_ID_30:
2345                 ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2346                 break;
2347         case IPR_HOST_RCB_OVERLAY_ID_1:
2348         case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2349         default:
2350                 ipr_log_generic_error(ioa_cfg, hostrcb);
2351                 break;
2352         }
2353 }
2354
2355 /**
2356  * ipr_process_error - Op done function for an adapter error log.
2357  * @ipr_cmd:    ipr command struct
2358  *
2359  * This function is the op done function for an error log host
2360  * controlled async from the adapter. It will log the error and
2361  * send the HCAM back to the adapter.
2362  *
2363  * Return value:
2364  *      none
2365  **/
2366 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2367 {
2368         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2369         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2370         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2371         u32 fd_ioasc;
2372
2373         if (ioa_cfg->sis64)
2374                 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2375         else
2376                 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2377
2378         list_del(&hostrcb->queue);
2379         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
2380
2381         if (!ioasc) {
2382                 ipr_handle_log_data(ioa_cfg, hostrcb);
2383                 if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2384                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2385         } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
2386                 dev_err(&ioa_cfg->pdev->dev,
2387                         "Host RCB failed with IOASC: 0x%08X\n", ioasc);
2388         }
2389
2390         ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2391 }
2392
2393 /**
2394  * ipr_timeout -  An internally generated op has timed out.
2395  * @ipr_cmd:    ipr command struct
2396  *
2397  * This function blocks host requests and initiates an
2398  * adapter reset.
2399  *
2400  * Return value:
2401  *      none
2402  **/
2403 static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
2404 {
2405         unsigned long lock_flags = 0;
2406         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2407
2408         ENTER;
2409         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2410
2411         ioa_cfg->errors_logged++;
2412         dev_err(&ioa_cfg->pdev->dev,
2413                 "Adapter being reset due to command timeout.\n");
2414
2415         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2416                 ioa_cfg->sdt_state = GET_DUMP;
2417
2418         if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2419                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2420
2421         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2422         LEAVE;
2423 }
2424
2425 /**
2426  * ipr_oper_timeout -  Adapter timed out transitioning to operational
2427  * @ipr_cmd:    ipr command struct
2428  *
2429  * This function blocks host requests and initiates an
2430  * adapter reset.
2431  *
2432  * Return value:
2433  *      none
2434  **/
2435 static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
2436 {
2437         unsigned long lock_flags = 0;
2438         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2439
2440         ENTER;
2441         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2442
2443         ioa_cfg->errors_logged++;
2444         dev_err(&ioa_cfg->pdev->dev,
2445                 "Adapter timed out transitioning to operational.\n");
2446
2447         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2448                 ioa_cfg->sdt_state = GET_DUMP;
2449
2450         if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2451                 if (ipr_fastfail)
2452                         ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2453                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2454         }
2455
2456         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2457         LEAVE;
2458 }
2459
2460 /**
2461  * ipr_reset_reload - Reset/Reload the IOA
2462  * @ioa_cfg:            ioa config struct
2463  * @shutdown_type:      shutdown type
2464  *
2465  * This function resets the adapter and re-initializes it.
2466  * This function assumes that all new host commands have been stopped.
2467  * Return value:
2468  *      SUCCESS / FAILED
2469  **/
2470 static int ipr_reset_reload(struct ipr_ioa_cfg *ioa_cfg,
2471                             enum ipr_shutdown_type shutdown_type)
2472 {
2473         if (!ioa_cfg->in_reset_reload)
2474                 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
2475
2476         spin_unlock_irq(ioa_cfg->host->host_lock);
2477         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2478         spin_lock_irq(ioa_cfg->host->host_lock);
2479
2480         /* If we got hit with a host reset while we were already resetting
2481          the adapter for some reason, and the reset failed. */
2482         if (ioa_cfg->ioa_is_dead) {
2483                 ipr_trace;
2484                 return FAILED;
2485         }
2486
2487         return SUCCESS;
2488 }
2489
2490 /**
2491  * ipr_find_ses_entry - Find matching SES in SES table
2492  * @res:        resource entry struct of SES
2493  *
2494  * Return value:
2495  *      pointer to SES table entry / NULL on failure
2496  **/
2497 static const struct ipr_ses_table_entry *
2498 ipr_find_ses_entry(struct ipr_resource_entry *res)
2499 {
2500         int i, j, matches;
2501         struct ipr_std_inq_vpids *vpids;
2502         const struct ipr_ses_table_entry *ste = ipr_ses_table;
2503
2504         for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2505                 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2506                         if (ste->compare_product_id_byte[j] == 'X') {
2507                                 vpids = &res->std_inq_data.vpids;
2508                                 if (vpids->product_id[j] == ste->product_id[j])
2509                                         matches++;
2510                                 else
2511                                         break;
2512                         } else
2513                                 matches++;
2514                 }
2515
2516                 if (matches == IPR_PROD_ID_LEN)
2517                         return ste;
2518         }
2519
2520         return NULL;
2521 }
2522
2523 /**
2524  * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2525  * @ioa_cfg:    ioa config struct
2526  * @bus:                SCSI bus
2527  * @bus_width:  bus width
2528  *
2529  * Return value:
2530  *      SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2531  *      For a 2-byte wide SCSI bus, the maximum transfer speed is
2532  *      twice the maximum transfer rate (e.g. for a wide enabled bus,
2533  *      max 160MHz = max 320MB/sec).
2534  **/
2535 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2536 {
2537         struct ipr_resource_entry *res;
2538         const struct ipr_ses_table_entry *ste;
2539         u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2540
2541         /* Loop through each config table entry in the config table buffer */
2542         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2543                 if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2544                         continue;
2545
2546                 if (bus != res->bus)
2547                         continue;
2548
2549                 if (!(ste = ipr_find_ses_entry(res)))
2550                         continue;
2551
2552                 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2553         }
2554
2555         return max_xfer_rate;
2556 }
2557
2558 /**
2559  * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2560  * @ioa_cfg:            ioa config struct
2561  * @max_delay:          max delay in micro-seconds to wait
2562  *
2563  * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2564  *
2565  * Return value:
2566  *      0 on success / other on failure
2567  **/
2568 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2569 {
2570         volatile u32 pcii_reg;
2571         int delay = 1;
2572
2573         /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2574         while (delay < max_delay) {
2575                 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2576
2577                 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2578                         return 0;
2579
2580                 /* udelay cannot be used if delay is more than a few milliseconds */
2581                 if ((delay / 1000) > MAX_UDELAY_MS)
2582                         mdelay(delay / 1000);
2583                 else
2584                         udelay(delay);
2585
2586                 delay += delay;
2587         }
2588         return -EIO;
2589 }
2590
2591 /**
2592  * ipr_get_sis64_dump_data_section - Dump IOA memory
2593  * @ioa_cfg:                    ioa config struct
2594  * @start_addr:                 adapter address to dump
2595  * @dest:                       destination kernel buffer
2596  * @length_in_words:            length to dump in 4 byte words
2597  *
2598  * Return value:
2599  *      0 on success
2600  **/
2601 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2602                                            u32 start_addr,
2603                                            __be32 *dest, u32 length_in_words)
2604 {
2605         int i;
2606
2607         for (i = 0; i < length_in_words; i++) {
2608                 writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2609                 *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2610                 dest++;
2611         }
2612
2613         return 0;
2614 }
2615
2616 /**
2617  * ipr_get_ldump_data_section - Dump IOA memory
2618  * @ioa_cfg:                    ioa config struct
2619  * @start_addr:                 adapter address to dump
2620  * @dest:                               destination kernel buffer
2621  * @length_in_words:    length to dump in 4 byte words
2622  *
2623  * Return value:
2624  *      0 on success / -EIO on failure
2625  **/
2626 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2627                                       u32 start_addr,
2628                                       __be32 *dest, u32 length_in_words)
2629 {
2630         volatile u32 temp_pcii_reg;
2631         int i, delay = 0;
2632
2633         if (ioa_cfg->sis64)
2634                 return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2635                                                        dest, length_in_words);
2636
2637         /* Write IOA interrupt reg starting LDUMP state  */
2638         writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2639                ioa_cfg->regs.set_uproc_interrupt_reg32);
2640
2641         /* Wait for IO debug acknowledge */
2642         if (ipr_wait_iodbg_ack(ioa_cfg,
2643                                IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2644                 dev_err(&ioa_cfg->pdev->dev,
2645                         "IOA dump long data transfer timeout\n");
2646                 return -EIO;
2647         }
2648
2649         /* Signal LDUMP interlocked - clear IO debug ack */
2650         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2651                ioa_cfg->regs.clr_interrupt_reg);
2652
2653         /* Write Mailbox with starting address */
2654         writel(start_addr, ioa_cfg->ioa_mailbox);
2655
2656         /* Signal address valid - clear IOA Reset alert */
2657         writel(IPR_UPROCI_RESET_ALERT,
2658                ioa_cfg->regs.clr_uproc_interrupt_reg32);
2659
2660         for (i = 0; i < length_in_words; i++) {
2661                 /* Wait for IO debug acknowledge */
2662                 if (ipr_wait_iodbg_ack(ioa_cfg,
2663                                        IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2664                         dev_err(&ioa_cfg->pdev->dev,
2665                                 "IOA dump short data transfer timeout\n");
2666                         return -EIO;
2667                 }
2668
2669                 /* Read data from mailbox and increment destination pointer */
2670                 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2671                 dest++;
2672
2673                 /* For all but the last word of data, signal data received */
2674                 if (i < (length_in_words - 1)) {
2675                         /* Signal dump data received - Clear IO debug Ack */
2676                         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2677                                ioa_cfg->regs.clr_interrupt_reg);
2678                 }
2679         }
2680
2681         /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2682         writel(IPR_UPROCI_RESET_ALERT,
2683                ioa_cfg->regs.set_uproc_interrupt_reg32);
2684
2685         writel(IPR_UPROCI_IO_DEBUG_ALERT,
2686                ioa_cfg->regs.clr_uproc_interrupt_reg32);
2687
2688         /* Signal dump data received - Clear IO debug Ack */
2689         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2690                ioa_cfg->regs.clr_interrupt_reg);
2691
2692         /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2693         while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2694                 temp_pcii_reg =
2695                     readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2696
2697                 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2698                         return 0;
2699
2700                 udelay(10);
2701                 delay += 10;
2702         }
2703
2704         return 0;
2705 }
2706
2707 #ifdef CONFIG_SCSI_IPR_DUMP
2708 /**
2709  * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2710  * @ioa_cfg:            ioa config struct
2711  * @pci_address:        adapter address
2712  * @length:                     length of data to copy
2713  *
2714  * Copy data from PCI adapter to kernel buffer.
2715  * Note: length MUST be a 4 byte multiple
2716  * Return value:
2717  *      0 on success / other on failure
2718  **/
2719 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2720                         unsigned long pci_address, u32 length)
2721 {
2722         int bytes_copied = 0;
2723         int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2724         __be32 *page;
2725         unsigned long lock_flags = 0;
2726         struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2727
2728         if (ioa_cfg->sis64)
2729                 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2730         else
2731                 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2732
2733         while (bytes_copied < length &&
2734                (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2735                 if (ioa_dump->page_offset >= PAGE_SIZE ||
2736                     ioa_dump->page_offset == 0) {
2737                         page = (__be32 *)__get_free_page(GFP_ATOMIC);
2738
2739                         if (!page) {
2740                                 ipr_trace;
2741                                 return bytes_copied;
2742                         }
2743
2744                         ioa_dump->page_offset = 0;
2745                         ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2746                         ioa_dump->next_page_index++;
2747                 } else
2748                         page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2749
2750                 rem_len = length - bytes_copied;
2751                 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2752                 cur_len = min(rem_len, rem_page_len);
2753
2754                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2755                 if (ioa_cfg->sdt_state == ABORT_DUMP) {
2756                         rc = -EIO;
2757                 } else {
2758                         rc = ipr_get_ldump_data_section(ioa_cfg,
2759                                                         pci_address + bytes_copied,
2760                                                         &page[ioa_dump->page_offset / 4],
2761                                                         (cur_len / sizeof(u32)));
2762                 }
2763                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2764
2765                 if (!rc) {
2766                         ioa_dump->page_offset += cur_len;
2767                         bytes_copied += cur_len;
2768                 } else {
2769                         ipr_trace;
2770                         break;
2771                 }
2772                 schedule();
2773         }
2774
2775         return bytes_copied;
2776 }
2777
2778 /**
2779  * ipr_init_dump_entry_hdr - Initialize a dump entry header.
2780  * @hdr:        dump entry header struct
2781  *
2782  * Return value:
2783  *      nothing
2784  **/
2785 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
2786 {
2787         hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
2788         hdr->num_elems = 1;
2789         hdr->offset = sizeof(*hdr);
2790         hdr->status = IPR_DUMP_STATUS_SUCCESS;
2791 }
2792
2793 /**
2794  * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
2795  * @ioa_cfg:    ioa config struct
2796  * @driver_dump:        driver dump struct
2797  *
2798  * Return value:
2799  *      nothing
2800  **/
2801 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
2802                                    struct ipr_driver_dump *driver_dump)
2803 {
2804         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2805
2806         ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
2807         driver_dump->ioa_type_entry.hdr.len =
2808                 sizeof(struct ipr_dump_ioa_type_entry) -
2809                 sizeof(struct ipr_dump_entry_header);
2810         driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2811         driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
2812         driver_dump->ioa_type_entry.type = ioa_cfg->type;
2813         driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
2814                 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
2815                 ucode_vpd->minor_release[1];
2816         driver_dump->hdr.num_entries++;
2817 }
2818
2819 /**
2820  * ipr_dump_version_data - Fill in the driver version in the dump.
2821  * @ioa_cfg:    ioa config struct
2822  * @driver_dump:        driver dump struct
2823  *
2824  * Return value:
2825  *      nothing
2826  **/
2827 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
2828                                   struct ipr_driver_dump *driver_dump)
2829 {
2830         ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
2831         driver_dump->version_entry.hdr.len =
2832                 sizeof(struct ipr_dump_version_entry) -
2833                 sizeof(struct ipr_dump_entry_header);
2834         driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2835         driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
2836         strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
2837         driver_dump->hdr.num_entries++;
2838 }
2839
2840 /**
2841  * ipr_dump_trace_data - Fill in the IOA trace in the dump.
2842  * @ioa_cfg:    ioa config struct
2843  * @driver_dump:        driver dump struct
2844  *
2845  * Return value:
2846  *      nothing
2847  **/
2848 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
2849                                    struct ipr_driver_dump *driver_dump)
2850 {
2851         ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
2852         driver_dump->trace_entry.hdr.len =
2853                 sizeof(struct ipr_dump_trace_entry) -
2854                 sizeof(struct ipr_dump_entry_header);
2855         driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2856         driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
2857         memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
2858         driver_dump->hdr.num_entries++;
2859 }
2860
2861 /**
2862  * ipr_dump_location_data - Fill in the IOA location in the dump.
2863  * @ioa_cfg:    ioa config struct
2864  * @driver_dump:        driver dump struct
2865  *
2866  * Return value:
2867  *      nothing
2868  **/
2869 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
2870                                    struct ipr_driver_dump *driver_dump)
2871 {
2872         ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
2873         driver_dump->location_entry.hdr.len =
2874                 sizeof(struct ipr_dump_location_entry) -
2875                 sizeof(struct ipr_dump_entry_header);
2876         driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2877         driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
2878         strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
2879         driver_dump->hdr.num_entries++;
2880 }
2881
2882 /**
2883  * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
2884  * @ioa_cfg:    ioa config struct
2885  * @dump:               dump struct
2886  *
2887  * Return value:
2888  *      nothing
2889  **/
2890 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
2891 {
2892         unsigned long start_addr, sdt_word;
2893         unsigned long lock_flags = 0;
2894         struct ipr_driver_dump *driver_dump = &dump->driver_dump;
2895         struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
2896         u32 num_entries, max_num_entries, start_off, end_off;
2897         u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
2898         struct ipr_sdt *sdt;
2899         int valid = 1;
2900         int i;
2901
2902         ENTER;
2903
2904         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2905
2906         if (ioa_cfg->sdt_state != READ_DUMP) {
2907                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2908                 return;
2909         }
2910
2911         if (ioa_cfg->sis64) {
2912                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2913                 ssleep(IPR_DUMP_DELAY_SECONDS);
2914                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2915         }
2916
2917         start_addr = readl(ioa_cfg->ioa_mailbox);
2918
2919         if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
2920                 dev_err(&ioa_cfg->pdev->dev,
2921                         "Invalid dump table format: %lx\n", start_addr);
2922                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2923                 return;
2924         }
2925
2926         dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
2927
2928         driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
2929
2930         /* Initialize the overall dump header */
2931         driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
2932         driver_dump->hdr.num_entries = 1;
2933         driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
2934         driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
2935         driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
2936         driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
2937
2938         ipr_dump_version_data(ioa_cfg, driver_dump);
2939         ipr_dump_location_data(ioa_cfg, driver_dump);
2940         ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
2941         ipr_dump_trace_data(ioa_cfg, driver_dump);
2942
2943         /* Update dump_header */
2944         driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
2945
2946         /* IOA Dump entry */
2947         ipr_init_dump_entry_hdr(&ioa_dump->hdr);
2948         ioa_dump->hdr.len = 0;
2949         ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2950         ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
2951
2952         /* First entries in sdt are actually a list of dump addresses and
2953          lengths to gather the real dump data.  sdt represents the pointer
2954          to the ioa generated dump table.  Dump data will be extracted based
2955          on entries in this table */
2956         sdt = &ioa_dump->sdt;
2957
2958         if (ioa_cfg->sis64) {
2959                 max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
2960                 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2961         } else {
2962                 max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
2963                 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2964         }
2965
2966         bytes_to_copy = offsetof(struct ipr_sdt, entry) +
2967                         (max_num_entries * sizeof(struct ipr_sdt_entry));
2968         rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
2969                                         bytes_to_copy / sizeof(__be32));
2970
2971         /* Smart Dump table is ready to use and the first entry is valid */
2972         if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
2973             (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
2974                 dev_err(&ioa_cfg->pdev->dev,
2975                         "Dump of IOA failed. Dump table not valid: %d, %X.\n",
2976                         rc, be32_to_cpu(sdt->hdr.state));
2977                 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
2978                 ioa_cfg->sdt_state = DUMP_OBTAINED;
2979                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2980                 return;
2981         }
2982
2983         num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
2984
2985         if (num_entries > max_num_entries)
2986                 num_entries = max_num_entries;
2987
2988         /* Update dump length to the actual data to be copied */
2989         dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
2990         if (ioa_cfg->sis64)
2991                 dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
2992         else
2993                 dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
2994
2995         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2996
2997         for (i = 0; i < num_entries; i++) {
2998                 if (ioa_dump->hdr.len > max_dump_size) {
2999                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3000                         break;
3001                 }
3002
3003                 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3004                         sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3005                         if (ioa_cfg->sis64)
3006                                 bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3007                         else {
3008                                 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3009                                 end_off = be32_to_cpu(sdt->entry[i].end_token);
3010
3011                                 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3012                                         bytes_to_copy = end_off - start_off;
3013                                 else
3014                                         valid = 0;
3015                         }
3016                         if (valid) {
3017                                 if (bytes_to_copy > max_dump_size) {
3018                                         sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3019                                         continue;
3020                                 }
3021
3022                                 /* Copy data from adapter to driver buffers */
3023                                 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3024                                                             bytes_to_copy);
3025
3026                                 ioa_dump->hdr.len += bytes_copied;
3027
3028                                 if (bytes_copied != bytes_to_copy) {
3029                                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3030                                         break;
3031                                 }
3032                         }
3033                 }
3034         }
3035
3036         dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3037
3038         /* Update dump_header */
3039         driver_dump->hdr.len += ioa_dump->hdr.len;
3040         wmb();
3041         ioa_cfg->sdt_state = DUMP_OBTAINED;
3042         LEAVE;
3043 }
3044
3045 #else
3046 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3047 #endif
3048
3049 /**
3050  * ipr_release_dump - Free adapter dump memory
3051  * @kref:       kref struct
3052  *
3053  * Return value:
3054  *      nothing
3055  **/
3056 static void ipr_release_dump(struct kref *kref)
3057 {
3058         struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3059         struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3060         unsigned long lock_flags = 0;
3061         int i;
3062
3063         ENTER;
3064         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3065         ioa_cfg->dump = NULL;
3066         ioa_cfg->sdt_state = INACTIVE;
3067         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3068
3069         for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3070                 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3071
3072         vfree(dump->ioa_dump.ioa_data);
3073         kfree(dump);
3074         LEAVE;
3075 }
3076
3077 /**
3078  * ipr_worker_thread - Worker thread
3079  * @work:               ioa config struct
3080  *
3081  * Called at task level from a work thread. This function takes care
3082  * of adding and removing device from the mid-layer as configuration
3083  * changes are detected by the adapter.
3084  *
3085  * Return value:
3086  *      nothing
3087  **/
3088 static void ipr_worker_thread(struct work_struct *work)
3089 {
3090         unsigned long lock_flags;
3091         struct ipr_resource_entry *res;
3092         struct scsi_device *sdev;
3093         struct ipr_dump *dump;
3094         struct ipr_ioa_cfg *ioa_cfg =
3095                 container_of(work, struct ipr_ioa_cfg, work_q);
3096         u8 bus, target, lun;
3097         int did_work;
3098
3099         ENTER;
3100         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3101
3102         if (ioa_cfg->sdt_state == READ_DUMP) {
3103                 dump = ioa_cfg->dump;
3104                 if (!dump) {
3105                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3106                         return;
3107                 }
3108                 kref_get(&dump->kref);
3109                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3110                 ipr_get_ioa_dump(ioa_cfg, dump);
3111                 kref_put(&dump->kref, ipr_release_dump);
3112
3113                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3114                 if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3115                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3116                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3117                 return;
3118         }
3119
3120 restart:
3121         do {
3122                 did_work = 0;
3123                 if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
3124                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3125                         return;
3126                 }
3127
3128                 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3129                         if (res->del_from_ml && res->sdev) {
3130                                 did_work = 1;
3131                                 sdev = res->sdev;
3132                                 if (!scsi_device_get(sdev)) {
3133                                         if (!res->add_to_ml)
3134                                                 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3135                                         else
3136                                                 res->del_from_ml = 0;
3137                                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3138                                         scsi_remove_device(sdev);
3139                                         scsi_device_put(sdev);
3140                                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3141                                 }
3142                                 break;
3143                         }
3144                 }
3145         } while (did_work);
3146
3147         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3148                 if (res->add_to_ml) {
3149                         bus = res->bus;
3150                         target = res->target;
3151                         lun = res->lun;
3152                         res->add_to_ml = 0;
3153                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3154                         scsi_add_device(ioa_cfg->host, bus, target, lun);
3155                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3156                         goto restart;
3157                 }
3158         }
3159
3160         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3161         kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3162         LEAVE;
3163 }
3164
3165 #ifdef CONFIG_SCSI_IPR_TRACE
3166 /**
3167  * ipr_read_trace - Dump the adapter trace
3168  * @filp:               open sysfs file
3169  * @kobj:               kobject struct
3170  * @bin_attr:           bin_attribute struct
3171  * @buf:                buffer
3172  * @off:                offset
3173  * @count:              buffer size
3174  *
3175  * Return value:
3176  *      number of bytes printed to buffer
3177  **/
3178 static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3179                               struct bin_attribute *bin_attr,
3180                               char *buf, loff_t off, size_t count)
3181 {
3182         struct device *dev = container_of(kobj, struct device, kobj);
3183         struct Scsi_Host *shost = class_to_shost(dev);
3184         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3185         unsigned long lock_flags = 0;
3186         ssize_t ret;
3187
3188         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3189         ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3190                                 IPR_TRACE_SIZE);
3191         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3192
3193         return ret;
3194 }
3195
3196 static struct bin_attribute ipr_trace_attr = {
3197         .attr = {
3198                 .name = "trace",
3199                 .mode = S_IRUGO,
3200         },
3201         .size = 0,
3202         .read = ipr_read_trace,
3203 };
3204 #endif
3205
3206 /**
3207  * ipr_show_fw_version - Show the firmware version
3208  * @dev:        class device struct
3209  * @buf:        buffer
3210  *
3211  * Return value:
3212  *      number of bytes printed to buffer
3213  **/
3214 static ssize_t ipr_show_fw_version(struct device *dev,
3215                                    struct device_attribute *attr, char *buf)
3216 {
3217         struct Scsi_Host *shost = class_to_shost(dev);
3218         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3219         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3220         unsigned long lock_flags = 0;
3221         int len;
3222
3223         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3224         len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3225                        ucode_vpd->major_release, ucode_vpd->card_type,
3226                        ucode_vpd->minor_release[0],
3227                        ucode_vpd->minor_release[1]);
3228         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3229         return len;
3230 }
3231
3232 static struct device_attribute ipr_fw_version_attr = {
3233         .attr = {
3234                 .name =         "fw_version",
3235                 .mode =         S_IRUGO,
3236         },
3237         .show = ipr_show_fw_version,
3238 };
3239
3240 /**
3241  * ipr_show_log_level - Show the adapter's error logging level
3242  * @dev:        class device struct
3243  * @buf:        buffer
3244  *
3245  * Return value:
3246  *      number of bytes printed to buffer
3247  **/
3248 static ssize_t ipr_show_log_level(struct device *dev,
3249                                    struct device_attribute *attr, char *buf)
3250 {
3251         struct Scsi_Host *shost = class_to_shost(dev);
3252         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3253         unsigned long lock_flags = 0;
3254         int len;
3255
3256         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3257         len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3258         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3259         return len;
3260 }
3261
3262 /**
3263  * ipr_store_log_level - Change the adapter's error logging level
3264  * @dev:        class device struct
3265  * @buf:        buffer
3266  *
3267  * Return value:
3268  *      number of bytes printed to buffer
3269  **/
3270 static ssize_t ipr_store_log_level(struct device *dev,
3271                                    struct device_attribute *attr,
3272                                    const char *buf, size_t count)
3273 {
3274         struct Scsi_Host *shost = class_to_shost(dev);
3275         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3276         unsigned long lock_flags = 0;
3277
3278         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3279         ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3280         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3281         return strlen(buf);
3282 }
3283
3284 static struct device_attribute ipr_log_level_attr = {
3285         .attr = {
3286                 .name =         "log_level",
3287                 .mode =         S_IRUGO | S_IWUSR,
3288         },
3289         .show = ipr_show_log_level,
3290         .store = ipr_store_log_level
3291 };
3292
3293 /**
3294  * ipr_store_diagnostics - IOA Diagnostics interface
3295  * @dev:        device struct
3296  * @buf:        buffer
3297  * @count:      buffer size
3298  *
3299  * This function will reset the adapter and wait a reasonable
3300  * amount of time for any errors that the adapter might log.
3301  *
3302  * Return value:
3303  *      count on success / other on failure
3304  **/
3305 static ssize_t ipr_store_diagnostics(struct device *dev,
3306                                      struct device_attribute *attr,
3307                                      const char *buf, size_t count)
3308 {
3309         struct Scsi_Host *shost = class_to_shost(dev);
3310         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3311         unsigned long lock_flags = 0;
3312         int rc = count;
3313
3314         if (!capable(CAP_SYS_ADMIN))
3315                 return -EACCES;
3316
3317         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3318         while (ioa_cfg->in_reset_reload) {
3319                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3320                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3321                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3322         }
3323
3324         ioa_cfg->errors_logged = 0;
3325         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3326
3327         if (ioa_cfg->in_reset_reload) {
3328                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3329                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3330
3331                 /* Wait for a second for any errors to be logged */
3332                 msleep(1000);
3333         } else {
3334                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3335                 return -EIO;
3336         }
3337
3338         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3339         if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3340                 rc = -EIO;
3341         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3342
3343         return rc;
3344 }
3345
3346 static struct device_attribute ipr_diagnostics_attr = {
3347         .attr = {
3348                 .name =         "run_diagnostics",
3349                 .mode =         S_IWUSR,
3350         },
3351         .store = ipr_store_diagnostics
3352 };
3353
3354 /**
3355  * ipr_show_adapter_state - Show the adapter's state
3356  * @class_dev:  device struct
3357  * @buf:        buffer
3358  *
3359  * Return value:
3360  *      number of bytes printed to buffer
3361  **/
3362 static ssize_t ipr_show_adapter_state(struct device *dev,
3363                                       struct device_attribute *attr, char *buf)
3364 {
3365         struct Scsi_Host *shost = class_to_shost(dev);
3366         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3367         unsigned long lock_flags = 0;
3368         int len;
3369
3370         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3371         if (ioa_cfg->ioa_is_dead)
3372                 len = snprintf(buf, PAGE_SIZE, "offline\n");
3373         else
3374                 len = snprintf(buf, PAGE_SIZE, "online\n");
3375         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3376         return len;
3377 }
3378
3379 /**
3380  * ipr_store_adapter_state - Change adapter state
3381  * @dev:        device struct
3382  * @buf:        buffer
3383  * @count:      buffer size
3384  *
3385  * This function will change the adapter's state.
3386  *
3387  * Return value:
3388  *      count on success / other on failure
3389  **/
3390 static ssize_t ipr_store_adapter_state(struct device *dev,
3391                                        struct device_attribute *attr,
3392                                        const char *buf, size_t count)
3393 {
3394         struct Scsi_Host *shost = class_to_shost(dev);
3395         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3396         unsigned long lock_flags;
3397         int result = count;
3398
3399         if (!capable(CAP_SYS_ADMIN))
3400                 return -EACCES;
3401
3402         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3403         if (ioa_cfg->ioa_is_dead && !strncmp(buf, "online", 6)) {
3404                 ioa_cfg->ioa_is_dead = 0;
3405                 ioa_cfg->reset_retries = 0;
3406                 ioa_cfg->in_ioa_bringdown = 0;
3407                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3408         }
3409         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3410         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3411
3412         return result;
3413 }
3414
3415 static struct device_attribute ipr_ioa_state_attr = {
3416         .attr = {
3417                 .name =         "online_state",
3418                 .mode =         S_IRUGO | S_IWUSR,
3419         },
3420         .show = ipr_show_adapter_state,
3421         .store = ipr_store_adapter_state
3422 };
3423
3424 /**
3425  * ipr_store_reset_adapter - Reset the adapter
3426  * @dev:        device struct
3427  * @buf:        buffer
3428  * @count:      buffer size
3429  *
3430  * This function will reset the adapter.
3431  *
3432  * Return value:
3433  *      count on success / other on failure
3434  **/
3435 static ssize_t ipr_store_reset_adapter(struct device *dev,
3436                                        struct device_attribute *attr,
3437                                        const char *buf, size_t count)
3438 {
3439         struct Scsi_Host *shost = class_to_shost(dev);
3440         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3441         unsigned long lock_flags;
3442         int result = count;
3443
3444         if (!capable(CAP_SYS_ADMIN))
3445                 return -EACCES;
3446
3447         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3448         if (!ioa_cfg->in_reset_reload)
3449                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3450         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3451         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3452
3453         return result;
3454 }
3455
3456 static struct device_attribute ipr_ioa_reset_attr = {
3457         .attr = {
3458                 .name =         "reset_host",
3459                 .mode =         S_IWUSR,
3460         },
3461         .store = ipr_store_reset_adapter
3462 };
3463
3464 /**
3465  * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3466  * @buf_len:            buffer length
3467  *
3468  * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3469  * list to use for microcode download
3470  *
3471  * Return value:
3472  *      pointer to sglist / NULL on failure
3473  **/
3474 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3475 {
3476         int sg_size, order, bsize_elem, num_elem, i, j;
3477         struct ipr_sglist *sglist;
3478         struct scatterlist *scatterlist;
3479         struct page *page;
3480
3481         /* Get the minimum size per scatter/gather element */
3482         sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3483
3484         /* Get the actual size per element */
3485         order = get_order(sg_size);
3486
3487         /* Determine the actual number of bytes per element */
3488         bsize_elem = PAGE_SIZE * (1 << order);
3489
3490         /* Determine the actual number of sg entries needed */
3491         if (buf_len % bsize_elem)
3492                 num_elem = (buf_len / bsize_elem) + 1;
3493         else
3494                 num_elem = buf_len / bsize_elem;
3495
3496         /* Allocate a scatter/gather list for the DMA */
3497         sglist = kzalloc(sizeof(struct ipr_sglist) +
3498                          (sizeof(struct scatterlist) * (num_elem - 1)),
3499                          GFP_KERNEL);
3500
3501         if (sglist == NULL) {
3502                 ipr_trace;
3503                 return NULL;
3504         }
3505
3506         scatterlist = sglist->scatterlist;
3507         sg_init_table(scatterlist, num_elem);
3508
3509         sglist->order = order;
3510         sglist->num_sg = num_elem;
3511
3512         /* Allocate a bunch of sg elements */
3513         for (i = 0; i < num_elem; i++) {
3514                 page = alloc_pages(GFP_KERNEL, order);
3515                 if (!page) {
3516                         ipr_trace;
3517
3518                         /* Free up what we already allocated */
3519                         for (j = i - 1; j >= 0; j--)
3520                                 __free_pages(sg_page(&scatterlist[j]), order);
3521                         kfree(sglist);
3522                         return NULL;
3523                 }
3524
3525                 sg_set_page(&scatterlist[i], page, 0, 0);
3526         }
3527
3528         return sglist;
3529 }
3530
3531 /**
3532  * ipr_free_ucode_buffer - Frees a microcode download buffer
3533  * @p_dnld:             scatter/gather list pointer
3534  *
3535  * Free a DMA'able ucode download buffer previously allocated with
3536  * ipr_alloc_ucode_buffer
3537  *
3538  * Return value:
3539  *      nothing
3540  **/
3541 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3542 {
3543         int i;
3544
3545         for (i = 0; i < sglist->num_sg; i++)
3546                 __free_pages(sg_page(&sglist->scatterlist[i]), sglist->order);
3547
3548         kfree(sglist);
3549 }
3550
3551 /**
3552  * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3553  * @sglist:             scatter/gather list pointer
3554  * @buffer:             buffer pointer
3555  * @len:                buffer length
3556  *
3557  * Copy a microcode image from a user buffer into a buffer allocated by
3558  * ipr_alloc_ucode_buffer
3559  *
3560  * Return value:
3561  *      0 on success / other on failure
3562  **/
3563 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3564                                  u8 *buffer, u32 len)
3565 {
3566         int bsize_elem, i, result = 0;
3567         struct scatterlist *scatterlist;
3568         void *kaddr;
3569
3570         /* Determine the actual number of bytes per element */
3571         bsize_elem = PAGE_SIZE * (1 << sglist->order);
3572
3573         scatterlist = sglist->scatterlist;
3574
3575         for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3576                 struct page *page = sg_page(&scatterlist[i]);
3577
3578                 kaddr = kmap(page);
3579                 memcpy(kaddr, buffer, bsize_elem);
3580                 kunmap(page);
3581
3582                 scatterlist[i].length = bsize_elem;
3583
3584                 if (result != 0) {
3585                         ipr_trace;
3586                         return result;
3587                 }
3588         }
3589
3590         if (len % bsize_elem) {
3591                 struct page *page = sg_page(&scatterlist[i]);
3592
3593                 kaddr = kmap(page);
3594                 memcpy(kaddr, buffer, len % bsize_elem);
3595                 kunmap(page);
3596
3597                 scatterlist[i].length = len % bsize_elem;
3598         }
3599
3600         sglist->buffer_len = len;
3601         return result;
3602 }
3603
3604 /**
3605  * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3606  * @ipr_cmd:            ipr command struct
3607  * @sglist:             scatter/gather list
3608  *
3609  * Builds a microcode download IOA data list (IOADL).
3610  *
3611  **/
3612 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3613                                     struct ipr_sglist *sglist)
3614 {
3615         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3616         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3617         struct scatterlist *scatterlist = sglist->scatterlist;
3618         int i;
3619
3620         ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3621         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3622         ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3623
3624         ioarcb->ioadl_len =
3625                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3626         for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3627                 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3628                 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
3629                 ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
3630         }
3631
3632         ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3633 }
3634
3635 /**
3636  * ipr_build_ucode_ioadl - Build a microcode download IOADL
3637  * @ipr_cmd:    ipr command struct
3638  * @sglist:             scatter/gather list
3639  *
3640  * Builds a microcode download IOA data list (IOADL).
3641  *
3642  **/
3643 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3644                                   struct ipr_sglist *sglist)
3645 {
3646         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3647         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3648         struct scatterlist *scatterlist = sglist->scatterlist;
3649         int i;
3650
3651         ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3652         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3653         ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3654
3655         ioarcb->ioadl_len =
3656                 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3657
3658         for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3659                 ioadl[i].flags_and_data_len =
3660                         cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
3661                 ioadl[i].address =
3662                         cpu_to_be32(sg_dma_address(&scatterlist[i]));
3663         }
3664
3665         ioadl[i-1].flags_and_data_len |=
3666                 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3667 }
3668
3669 /**
3670  * ipr_update_ioa_ucode - Update IOA's microcode
3671  * @ioa_cfg:    ioa config struct
3672  * @sglist:             scatter/gather list
3673  *
3674  * Initiate an adapter reset to update the IOA's microcode
3675  *
3676  * Return value:
3677  *      0 on success / -EIO on failure
3678  **/
3679 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
3680                                 struct ipr_sglist *sglist)
3681 {
3682         unsigned long lock_flags;
3683
3684         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3685         while (ioa_cfg->in_reset_reload) {
3686                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3687                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3688                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3689         }
3690
3691         if (ioa_cfg->ucode_sglist) {
3692                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3693                 dev_err(&ioa_cfg->pdev->dev,
3694                         "Microcode download already in progress\n");
3695                 return -EIO;
3696         }
3697
3698         sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
3699                                         sglist->num_sg, DMA_TO_DEVICE);
3700
3701         if (!sglist->num_dma_sg) {
3702                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3703                 dev_err(&ioa_cfg->pdev->dev,
3704                         "Failed to map microcode download buffer!\n");
3705                 return -EIO;
3706         }
3707
3708         ioa_cfg->ucode_sglist = sglist;
3709         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3710         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3711         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3712
3713         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3714         ioa_cfg->ucode_sglist = NULL;
3715         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3716         return 0;
3717 }
3718
3719 /**
3720  * ipr_store_update_fw - Update the firmware on the adapter
3721  * @class_dev:  device struct
3722  * @buf:        buffer
3723  * @count:      buffer size
3724  *
3725  * This function will update the firmware on the adapter.
3726  *
3727  * Return value:
3728  *      count on success / other on failure
3729  **/
3730 static ssize_t ipr_store_update_fw(struct device *dev,
3731                                    struct device_attribute *attr,
3732                                    const char *buf, size_t count)
3733 {
3734         struct Scsi_Host *shost = class_to_shost(dev);
3735         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3736         struct ipr_ucode_image_header *image_hdr;
3737         const struct firmware *fw_entry;
3738         struct ipr_sglist *sglist;
3739         char fname[100];
3740         char *src;
3741         int len, result, dnld_size;
3742
3743         if (!capable(CAP_SYS_ADMIN))
3744                 return -EACCES;
3745
3746         len = snprintf(fname, 99, "%s", buf);
3747         fname[len-1] = '\0';
3748
3749         if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
3750                 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
3751                 return -EIO;
3752         }
3753
3754         image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
3755
3756         src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
3757         dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
3758         sglist = ipr_alloc_ucode_buffer(dnld_size);
3759
3760         if (!sglist) {
3761                 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
3762                 release_firmware(fw_entry);
3763                 return -ENOMEM;
3764         }
3765
3766         result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
3767
3768         if (result) {
3769                 dev_err(&ioa_cfg->pdev->dev,
3770                         "Microcode buffer copy to DMA buffer failed\n");
3771                 goto out;
3772         }
3773
3774         ipr_info("Updating microcode, please be patient.  This may take up to 30 minutes.\n");
3775
3776         result = ipr_update_ioa_ucode(ioa_cfg, sglist);
3777
3778         if (!result)
3779                 result = count;
3780 out:
3781         ipr_free_ucode_buffer(sglist);
3782         release_firmware(fw_entry);
3783         return result;
3784 }
3785
3786 static struct device_attribute ipr_update_fw_attr = {
3787         .attr = {
3788                 .name =         "update_fw",
3789                 .mode =         S_IWUSR,
3790         },
3791         .store = ipr_store_update_fw
3792 };
3793
3794 /**
3795  * ipr_show_fw_type - Show the adapter's firmware type.
3796  * @dev:        class device struct
3797  * @buf:        buffer
3798  *
3799  * Return value:
3800  *      number of bytes printed to buffer
3801  **/
3802 static ssize_t ipr_show_fw_type(struct device *dev,
3803                                 struct device_attribute *attr, char *buf)
3804 {
3805         struct Scsi_Host *shost = class_to_shost(dev);
3806         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3807         unsigned long lock_flags = 0;
3808         int len;
3809
3810         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3811         len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
3812         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3813         return len;
3814 }
3815
3816 static struct device_attribute ipr_ioa_fw_type_attr = {
3817         .attr = {
3818                 .name =         "fw_type",
3819                 .mode =         S_IRUGO,
3820         },
3821         .show = ipr_show_fw_type
3822 };
3823
3824 static struct device_attribute *ipr_ioa_attrs[] = {
3825         &ipr_fw_version_attr,
3826         &ipr_log_level_attr,
3827         &ipr_diagnostics_attr,
3828         &ipr_ioa_state_attr,
3829         &ipr_ioa_reset_attr,
3830         &ipr_update_fw_attr,
3831         &ipr_ioa_fw_type_attr,
3832         NULL,
3833 };
3834
3835 #ifdef CONFIG_SCSI_IPR_DUMP
3836 /**
3837  * ipr_read_dump - Dump the adapter
3838  * @filp:               open sysfs file
3839  * @kobj:               kobject struct
3840  * @bin_attr:           bin_attribute struct
3841  * @buf:                buffer
3842  * @off:                offset
3843  * @count:              buffer size
3844  *
3845  * Return value:
3846  *      number of bytes printed to buffer
3847  **/
3848 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
3849                              struct bin_attribute *bin_attr,
3850                              char *buf, loff_t off, size_t count)
3851 {
3852         struct device *cdev = container_of(kobj, struct device, kobj);
3853         struct Scsi_Host *shost = class_to_shost(cdev);
3854         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3855         struct ipr_dump *dump;
3856         unsigned long lock_flags = 0;
3857         char *src;
3858         int len, sdt_end;
3859         size_t rc = count;
3860
3861         if (!capable(CAP_SYS_ADMIN))
3862                 return -EACCES;
3863
3864         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3865         dump = ioa_cfg->dump;
3866
3867         if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
3868                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3869                 return 0;
3870         }
3871         kref_get(&dump->kref);
3872         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3873
3874         if (off > dump->driver_dump.hdr.len) {
3875                 kref_put(&dump->kref, ipr_release_dump);
3876                 return 0;
3877         }
3878
3879         if (off + count > dump->driver_dump.hdr.len) {
3880                 count = dump->driver_dump.hdr.len - off;
3881                 rc = count;
3882         }
3883
3884         if (count && off < sizeof(dump->driver_dump)) {
3885                 if (off + count > sizeof(dump->driver_dump))
3886                         len = sizeof(dump->driver_dump) - off;
3887                 else
3888                         len = count;
3889                 src = (u8 *)&dump->driver_dump + off;
3890                 memcpy(buf, src, len);
3891                 buf += len;
3892                 off += len;
3893                 count -= len;
3894         }
3895
3896         off -= sizeof(dump->driver_dump);
3897
3898         if (ioa_cfg->sis64)
3899                 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
3900                           (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
3901                            sizeof(struct ipr_sdt_entry));
3902         else
3903                 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
3904                           (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
3905
3906         if (count && off < sdt_end) {
3907                 if (off + count > sdt_end)
3908                         len = sdt_end - off;
3909                 else
3910                         len = count;
3911                 src = (u8 *)&dump->ioa_dump + off;
3912                 memcpy(buf, src, len);
3913                 buf += len;
3914                 off += len;
3915                 count -= len;
3916         }
3917
3918         off -= sdt_end;
3919
3920         while (count) {
3921                 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
3922                         len = PAGE_ALIGN(off) - off;
3923                 else
3924                         len = count;
3925                 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
3926                 src += off & ~PAGE_MASK;
3927                 memcpy(buf, src, len);
3928                 buf += len;
3929                 off += len;
3930                 count -= len;
3931         }
3932
3933         kref_put(&dump->kref, ipr_release_dump);
3934         return rc;
3935 }
3936
3937 /**
3938  * ipr_alloc_dump - Prepare for adapter dump
3939  * @ioa_cfg:    ioa config struct
3940  *
3941  * Return value:
3942  *      0 on success / other on failure
3943  **/
3944 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
3945 {
3946         struct ipr_dump *dump;
3947         __be32 **ioa_data;
3948         unsigned long lock_flags = 0;
3949
3950         dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
3951
3952         if (!dump) {
3953                 ipr_err("Dump memory allocation failed\n");
3954                 return -ENOMEM;
3955         }
3956
3957         if (ioa_cfg->sis64)
3958                 ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
3959         else
3960                 ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
3961
3962         if (!ioa_data) {
3963                 ipr_err("Dump memory allocation failed\n");
3964                 kfree(dump);
3965                 return -ENOMEM;
3966         }
3967
3968         dump->ioa_dump.ioa_data = ioa_data;
3969
3970         kref_init(&dump->kref);
3971         dump->ioa_cfg = ioa_cfg;
3972
3973         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3974
3975         if (INACTIVE != ioa_cfg->sdt_state) {
3976                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3977                 vfree(dump->ioa_dump.ioa_data);
3978                 kfree(dump);
3979                 return 0;
3980         }
3981
3982         ioa_cfg->dump = dump;
3983         ioa_cfg->sdt_state = WAIT_FOR_DUMP;
3984         if (ioa_cfg->ioa_is_dead && !ioa_cfg->dump_taken) {
3985                 ioa_cfg->dump_taken = 1;
3986                 schedule_work(&ioa_cfg->work_q);
3987         }
3988         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3989
3990         return 0;
3991 }
3992
3993 /**
3994  * ipr_free_dump - Free adapter dump memory
3995  * @ioa_cfg:    ioa config struct
3996  *
3997  * Return value:
3998  *      0 on success / other on failure
3999  **/
4000 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4001 {
4002         struct ipr_dump *dump;
4003         unsigned long lock_flags = 0;
4004
4005         ENTER;
4006
4007         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4008         dump = ioa_cfg->dump;
4009         if (!dump) {
4010                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4011                 return 0;
4012         }
4013
4014         ioa_cfg->dump = NULL;
4015         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4016
4017         kref_put(&dump->kref, ipr_release_dump);
4018
4019         LEAVE;
4020         return 0;
4021 }
4022
4023 /**
4024  * ipr_write_dump - Setup dump state of adapter
4025  * @filp:               open sysfs file
4026  * @kobj:               kobject struct
4027  * @bin_attr:           bin_attribute struct
4028  * @buf:                buffer
4029  * @off:                offset
4030  * @count:              buffer size
4031  *
4032  * Return value:
4033  *      number of bytes printed to buffer
4034  **/
4035 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4036                               struct bin_attribute *bin_attr,
4037                               char *buf, loff_t off, size_t count)
4038 {
4039         struct device *cdev = container_of(kobj, struct device, kobj);
4040         struct Scsi_Host *shost = class_to_shost(cdev);
4041         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4042         int rc;
4043
4044         if (!capable(CAP_SYS_ADMIN))
4045                 return -EACCES;
4046
4047         if (buf[0] == '1')
4048                 rc = ipr_alloc_dump(ioa_cfg);
4049         else if (buf[0] == '0')
4050                 rc = ipr_free_dump(ioa_cfg);
4051         else
4052                 return -EINVAL;
4053
4054         if (rc)
4055                 return rc;
4056         else
4057                 return count;
4058 }
4059
4060 static struct bin_attribute ipr_dump_attr = {
4061         .attr = {
4062                 .name = "dump",
4063                 .mode = S_IRUSR | S_IWUSR,
4064         },
4065         .size = 0,
4066         .read = ipr_read_dump,
4067         .write = ipr_write_dump
4068 };
4069 #else
4070 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4071 #endif
4072
4073 /**
4074  * ipr_change_queue_depth - Change the device's queue depth
4075  * @sdev:       scsi device struct
4076  * @qdepth:     depth to set
4077  * @reason:     calling context
4078  *
4079  * Return value:
4080  *      actual depth set
4081  **/
4082 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
4083                                   int reason)
4084 {
4085         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4086         struct ipr_resource_entry *res;
4087         unsigned long lock_flags = 0;
4088
4089         if (reason != SCSI_QDEPTH_DEFAULT)
4090                 return -EOPNOTSUPP;
4091
4092         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4093         res = (struct ipr_resource_entry *)sdev->hostdata;
4094
4095         if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4096                 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4097         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4098
4099         scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
4100         return sdev->queue_depth;
4101 }
4102
4103 /**
4104  * ipr_change_queue_type - Change the device's queue type
4105  * @dsev:               scsi device struct
4106  * @tag_type:   type of tags to use
4107  *
4108  * Return value:
4109  *      actual queue type set
4110  **/
4111 static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
4112 {
4113         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4114         struct ipr_resource_entry *res;
4115         unsigned long lock_flags = 0;
4116
4117         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4118         res = (struct ipr_resource_entry *)sdev->hostdata;
4119
4120         if (res) {
4121                 if (ipr_is_gscsi(res) && sdev->tagged_supported) {
4122                         /*
4123                          * We don't bother quiescing the device here since the
4124                          * adapter firmware does it for us.
4125                          */
4126                         scsi_set_tag_type(sdev, tag_type);
4127
4128                         if (tag_type)
4129                                 scsi_activate_tcq(sdev, sdev->queue_depth);
4130                         else
4131                                 scsi_deactivate_tcq(sdev, sdev->queue_depth);
4132                 } else
4133                         tag_type = 0;
4134         } else
4135                 tag_type = 0;
4136
4137         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4138         return tag_type;
4139 }
4140
4141 /**
4142  * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4143  * @dev:        device struct
4144  * @attr:       device attribute structure
4145  * @buf:        buffer
4146  *
4147  * Return value:
4148  *      number of bytes printed to buffer
4149  **/
4150 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4151 {
4152         struct scsi_device *sdev = to_scsi_device(dev);
4153         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4154         struct ipr_resource_entry *res;
4155         unsigned long lock_flags = 0;
4156         ssize_t len = -ENXIO;
4157
4158         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4159         res = (struct ipr_resource_entry *)sdev->hostdata;
4160         if (res)
4161                 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4162         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4163         return len;
4164 }
4165
4166 static struct device_attribute ipr_adapter_handle_attr = {
4167         .attr = {
4168                 .name =         "adapter_handle",
4169                 .mode =         S_IRUSR,
4170         },
4171         .show = ipr_show_adapter_handle
4172 };
4173
4174 /**
4175  * ipr_show_resource_path - Show the resource path or the resource address for
4176  *                          this device.
4177  * @dev:        device struct
4178  * @attr:       device attribute structure
4179  * @buf:        buffer
4180  *
4181  * Return value:
4182  *      number of bytes printed to buffer
4183  **/
4184 static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4185 {
4186         struct scsi_device *sdev = to_scsi_device(dev);
4187         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4188         struct ipr_resource_entry *res;
4189         unsigned long lock_flags = 0;
4190         ssize_t len = -ENXIO;
4191         char buffer[IPR_MAX_RES_PATH_LENGTH];
4192
4193         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4194         res = (struct ipr_resource_entry *)sdev->hostdata;
4195         if (res && ioa_cfg->sis64)
4196                 len = snprintf(buf, PAGE_SIZE, "%s\n",
4197                                ipr_format_res_path(res->res_path, buffer,
4198                                                    sizeof(buffer)));
4199         else if (res)
4200                 len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4201                                res->bus, res->target, res->lun);
4202
4203         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4204         return len;
4205 }
4206
4207 static struct device_attribute ipr_resource_path_attr = {
4208         .attr = {
4209                 .name =         "resource_path",
4210                 .mode =         S_IRUGO,
4211         },
4212         .show = ipr_show_resource_path
4213 };
4214
4215 /**
4216  * ipr_show_device_id - Show the device_id for this device.
4217  * @dev:        device struct
4218  * @attr:       device attribute structure
4219  * @buf:        buffer
4220  *
4221  * Return value:
4222  *      number of bytes printed to buffer
4223  **/
4224 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4225 {
4226         struct scsi_device *sdev = to_scsi_device(dev);
4227         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4228         struct ipr_resource_entry *res;
4229         unsigned long lock_flags = 0;
4230         ssize_t len = -ENXIO;
4231
4232         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4233         res = (struct ipr_resource_entry *)sdev->hostdata;
4234         if (res && ioa_cfg->sis64)
4235                 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->dev_id);
4236         else if (res)
4237                 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4238
4239         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4240         return len;
4241 }
4242
4243 static struct device_attribute ipr_device_id_attr = {
4244         .attr = {
4245                 .name =         "device_id",
4246                 .mode =         S_IRUGO,
4247         },
4248         .show = ipr_show_device_id
4249 };
4250
4251 /**
4252  * ipr_show_resource_type - Show the resource type for this device.
4253  * @dev:        device struct
4254  * @attr:       device attribute structure
4255  * @buf:        buffer
4256  *
4257  * Return value:
4258  *      number of bytes printed to buffer
4259  **/
4260 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4261 {
4262         struct scsi_device *sdev = to_scsi_device(dev);
4263         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4264         struct ipr_resource_entry *res;
4265         unsigned long lock_flags = 0;
4266         ssize_t len = -ENXIO;
4267
4268         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4269         res = (struct ipr_resource_entry *)sdev->hostdata;
4270
4271         if (res)
4272                 len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4273
4274         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4275         return len;
4276 }
4277
4278 static struct device_attribute ipr_resource_type_attr = {
4279         .attr = {
4280                 .name =         "resource_type",
4281                 .mode =         S_IRUGO,
4282         },
4283         .show = ipr_show_resource_type
4284 };
4285
4286 static struct device_attribute *ipr_dev_attrs[] = {
4287         &ipr_adapter_handle_attr,
4288         &ipr_resource_path_attr,
4289         &ipr_device_id_attr,
4290         &ipr_resource_type_attr,
4291         NULL,
4292 };
4293
4294 /**
4295  * ipr_biosparam - Return the HSC mapping
4296  * @sdev:                       scsi device struct
4297  * @block_device:       block device pointer
4298  * @capacity:           capacity of the device
4299  * @parm:                       Array containing returned HSC values.
4300  *
4301  * This function generates the HSC parms that fdisk uses.
4302  * We want to make sure we return something that places partitions
4303  * on 4k boundaries for best performance with the IOA.
4304  *
4305  * Return value:
4306  *      0 on success
4307  **/
4308 static int ipr_biosparam(struct scsi_device *sdev,
4309                          struct block_device *block_device,
4310                          sector_t capacity, int *parm)
4311 {
4312         int heads, sectors;
4313         sector_t cylinders;
4314
4315         heads = 128;
4316         sectors = 32;
4317
4318         cylinders = capacity;
4319         sector_div(cylinders, (128 * 32));
4320
4321         /* return result */
4322         parm[0] = heads;
4323         parm[1] = sectors;
4324         parm[2] = cylinders;
4325
4326         return 0;
4327 }
4328
4329 /**
4330  * ipr_find_starget - Find target based on bus/target.
4331  * @starget:    scsi target struct
4332  *
4333  * Return value:
4334  *      resource entry pointer if found / NULL if not found
4335  **/
4336 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4337 {
4338         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4339         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4340         struct ipr_resource_entry *res;
4341
4342         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4343                 if ((res->bus == starget->channel) &&
4344                     (res->target == starget->id)) {
4345                         return res;
4346                 }
4347         }
4348
4349         return NULL;
4350 }
4351
4352 static struct ata_port_info sata_port_info;
4353
4354 /**
4355  * ipr_target_alloc - Prepare for commands to a SCSI target
4356  * @starget:    scsi target struct
4357  *
4358  * If the device is a SATA device, this function allocates an
4359  * ATA port with libata, else it does nothing.
4360  *
4361  * Return value:
4362  *      0 on success / non-0 on failure
4363  **/
4364 static int ipr_target_alloc(struct scsi_target *starget)
4365 {
4366         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4367         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4368         struct ipr_sata_port *sata_port;
4369         struct ata_port *ap;
4370         struct ipr_resource_entry *res;
4371         unsigned long lock_flags;
4372
4373         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4374         res = ipr_find_starget(starget);
4375         starget->hostdata = NULL;
4376
4377         if (res && ipr_is_gata(res)) {
4378                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4379                 sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4380                 if (!sata_port)
4381                         return -ENOMEM;
4382
4383                 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4384                 if (ap) {
4385                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4386                         sata_port->ioa_cfg = ioa_cfg;
4387                         sata_port->ap = ap;
4388                         sata_port->res = res;
4389
4390                         res->sata_port = sata_port;
4391                         ap->private_data = sata_port;
4392                         starget->hostdata = sata_port;
4393                 } else {
4394                         kfree(sata_port);
4395                         return -ENOMEM;
4396                 }
4397         }
4398         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4399
4400         return 0;
4401 }
4402
4403 /**
4404  * ipr_target_destroy - Destroy a SCSI target
4405  * @starget:    scsi target struct
4406  *
4407  * If the device was a SATA device, this function frees the libata
4408  * ATA port, else it does nothing.
4409  *
4410  **/
4411 static void ipr_target_destroy(struct scsi_target *starget)
4412 {
4413         struct ipr_sata_port *sata_port = starget->hostdata;
4414         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4415         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4416
4417         if (ioa_cfg->sis64) {
4418                 if (!ipr_find_starget(starget)) {
4419                         if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4420                                 clear_bit(starget->id, ioa_cfg->array_ids);
4421                         else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4422                                 clear_bit(starget->id, ioa_cfg->vset_ids);
4423                         else if (starget->channel == 0)
4424                                 clear_bit(starget->id, ioa_cfg->target_ids);
4425                 }
4426         }
4427
4428         if (sata_port) {
4429                 starget->hostdata = NULL;
4430                 ata_sas_port_destroy(sata_port->ap);
4431                 kfree(sata_port);
4432         }
4433 }
4434
4435 /**
4436  * ipr_find_sdev - Find device based on bus/target/lun.
4437  * @sdev:       scsi device struct
4438  *
4439  * Return value:
4440  *      resource entry pointer if found / NULL if not found
4441  **/
4442 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4443 {
4444         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4445         struct ipr_resource_entry *res;
4446
4447         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4448                 if ((res->bus == sdev->channel) &&
4449                     (res->target == sdev->id) &&
4450                     (res->lun == sdev->lun))
4451                         return res;
4452         }
4453
4454         return NULL;
4455 }
4456
4457 /**
4458  * ipr_slave_destroy - Unconfigure a SCSI device
4459  * @sdev:       scsi device struct
4460  *
4461  * Return value:
4462  *      nothing
4463  **/
4464 static void ipr_slave_destroy(struct scsi_device *sdev)
4465 {
4466         struct ipr_resource_entry *res;
4467         struct ipr_ioa_cfg *ioa_cfg;
4468         unsigned long lock_flags = 0;
4469
4470         ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4471
4472         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4473         res = (struct ipr_resource_entry *) sdev->hostdata;
4474         if (res) {
4475                 if (res->sata_port)
4476                         res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4477                 sdev->hostdata = NULL;
4478                 res->sdev = NULL;
4479                 res->sata_port = NULL;
4480         }
4481         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4482 }
4483
4484 /**
4485  * ipr_slave_configure - Configure a SCSI device
4486  * @sdev:       scsi device struct
4487  *
4488  * This function configures the specified scsi device.
4489  *
4490  * Return value:
4491  *      0 on success
4492  **/
4493 static int ipr_slave_configure(struct scsi_device *sdev)
4494 {
4495         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4496         struct ipr_resource_entry *res;
4497         struct ata_port *ap = NULL;
4498         unsigned long lock_flags = 0;
4499         char buffer[IPR_MAX_RES_PATH_LENGTH];
4500
4501         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4502         res = sdev->hostdata;
4503         if (res) {
4504                 if (ipr_is_af_dasd_device(res))
4505                         sdev->type = TYPE_RAID;
4506                 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4507                         sdev->scsi_level = 4;
4508                         sdev->no_uld_attach = 1;
4509                 }
4510                 if (ipr_is_vset_device(res)) {
4511                         blk_queue_rq_timeout(sdev->request_queue,
4512                                              IPR_VSET_RW_TIMEOUT);
4513                         blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4514                 }
4515                 if (ipr_is_gata(res) && res->sata_port)
4516                         ap = res->sata_port->ap;
4517                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4518
4519                 if (ap) {
4520                         scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
4521                         ata_sas_slave_configure(sdev, ap);
4522                 } else
4523                         scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
4524                 if (ioa_cfg->sis64)
4525                         sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4526                                     ipr_format_res_path(res->res_path, buffer,
4527                                                         sizeof(buffer)));
4528                 return 0;
4529         }
4530         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4531         return 0;
4532 }
4533
4534 /**
4535  * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4536  * @sdev:       scsi device struct
4537  *
4538  * This function initializes an ATA port so that future commands
4539  * sent through queuecommand will work.
4540  *
4541  * Return value:
4542  *      0 on success
4543  **/
4544 static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4545 {
4546         struct ipr_sata_port *sata_port = NULL;
4547         int rc = -ENXIO;
4548
4549         ENTER;
4550         if (sdev->sdev_target)
4551                 sata_port = sdev->sdev_target->hostdata;
4552         if (sata_port) {
4553                 rc = ata_sas_port_init(sata_port->ap);
4554                 if (rc == 0)
4555                         rc = ata_sas_sync_probe(sata_port->ap);
4556         }
4557
4558         if (rc)
4559                 ipr_slave_destroy(sdev);
4560
4561         LEAVE;
4562         return rc;
4563 }
4564
4565 /**
4566  * ipr_slave_alloc - Prepare for commands to a device.
4567  * @sdev:       scsi device struct
4568  *
4569  * This function saves a pointer to the resource entry
4570  * in the scsi device struct if the device exists. We
4571  * can then use this pointer in ipr_queuecommand when
4572  * handling new commands.
4573  *
4574  * Return value:
4575  *      0 on success / -ENXIO if device does not exist
4576  **/
4577 static int ipr_slave_alloc(struct scsi_device *sdev)
4578 {
4579         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4580         struct ipr_resource_entry *res;
4581         unsigned long lock_flags;
4582         int rc = -ENXIO;
4583
4584         sdev->hostdata = NULL;
4585
4586         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4587
4588         res = ipr_find_sdev(sdev);
4589         if (res) {
4590                 res->sdev = sdev;
4591                 res->add_to_ml = 0;
4592                 res->in_erp = 0;
4593                 sdev->hostdata = res;
4594                 if (!ipr_is_naca_model(res))
4595                         res->needs_sync_complete = 1;
4596                 rc = 0;
4597                 if (ipr_is_gata(res)) {
4598                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4599                         return ipr_ata_slave_alloc(sdev);
4600                 }
4601         }
4602
4603         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4604
4605         return rc;
4606 }
4607
4608 /**
4609  * ipr_eh_host_reset - Reset the host adapter
4610  * @scsi_cmd:   scsi command struct
4611  *
4612  * Return value:
4613  *      SUCCESS / FAILED
4614  **/
4615 static int __ipr_eh_host_reset(struct scsi_cmnd *scsi_cmd)
4616 {
4617         struct ipr_ioa_cfg *ioa_cfg;
4618         int rc;
4619
4620         ENTER;
4621         ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
4622
4623         if (!ioa_cfg->in_reset_reload) {
4624                 dev_err(&ioa_cfg->pdev->dev,
4625                         "Adapter being reset as a result of error recovery.\n");
4626
4627                 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
4628                         ioa_cfg->sdt_state = GET_DUMP;
4629         }
4630
4631         rc = ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
4632
4633         LEAVE;
4634         return rc;
4635 }
4636
4637 static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
4638 {
4639         int rc;
4640
4641         spin_lock_irq(cmd->device->host->host_lock);
4642         rc = __ipr_eh_host_reset(cmd);
4643         spin_unlock_irq(cmd->device->host->host_lock);
4644
4645         return rc;
4646 }
4647
4648 /**
4649  * ipr_device_reset - Reset the device
4650  * @ioa_cfg:    ioa config struct
4651  * @res:                resource entry struct
4652  *
4653  * This function issues a device reset to the affected device.
4654  * If the device is a SCSI device, a LUN reset will be sent
4655  * to the device first. If that does not work, a target reset
4656  * will be sent. If the device is a SATA device, a PHY reset will
4657  * be sent.
4658  *
4659  * Return value:
4660  *      0 on success / non-zero on failure
4661  **/
4662 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
4663                             struct ipr_resource_entry *res)
4664 {
4665         struct ipr_cmnd *ipr_cmd;
4666         struct ipr_ioarcb *ioarcb;
4667         struct ipr_cmd_pkt *cmd_pkt;
4668         struct ipr_ioarcb_ata_regs *regs;
4669         u32 ioasc;
4670
4671         ENTER;
4672         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4673         ioarcb = &ipr_cmd->ioarcb;
4674         cmd_pkt = &ioarcb->cmd_pkt;
4675
4676         if (ipr_cmd->ioa_cfg->sis64) {
4677                 regs = &ipr_cmd->i.ata_ioadl.regs;
4678                 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
4679         } else
4680                 regs = &ioarcb->u.add_data.u.regs;
4681
4682         ioarcb->res_handle = res->res_handle;
4683         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4684         cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
4685         if (ipr_is_gata(res)) {
4686                 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
4687                 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
4688                 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
4689         }
4690
4691         ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
4692         ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
4693         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4694         if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
4695                 if (ipr_cmd->ioa_cfg->sis64)
4696                         memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
4697                                sizeof(struct ipr_ioasa_gata));
4698                 else
4699                         memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
4700                                sizeof(struct ipr_ioasa_gata));
4701         }
4702
4703         LEAVE;
4704         return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
4705 }
4706
4707 /**
4708  * ipr_sata_reset - Reset the SATA port
4709  * @link:       SATA link to reset
4710  * @classes:    class of the attached device
4711  *
4712  * This function issues a SATA phy reset to the affected ATA link.
4713  *
4714  * Return value:
4715  *      0 on success / non-zero on failure
4716  **/
4717 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
4718                                 unsigned long deadline)
4719 {
4720         struct ipr_sata_port *sata_port = link->ap->private_data;
4721         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
4722         struct ipr_resource_entry *res;
4723         unsigned long lock_flags = 0;
4724         int rc = -ENXIO;
4725
4726         ENTER;
4727         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4728         while (ioa_cfg->in_reset_reload) {
4729                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4730                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4731                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4732         }
4733
4734         res = sata_port->res;
4735         if (res) {
4736                 rc = ipr_device_reset(ioa_cfg, res);
4737                 *classes = res->ata_class;
4738         }
4739
4740         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4741         LEAVE;
4742         return rc;
4743 }
4744
4745 /**
4746  * ipr_eh_dev_reset - Reset the device
4747  * @scsi_cmd:   scsi command struct
4748  *
4749  * This function issues a device reset to the affected device.
4750  * A LUN reset will be sent to the device first. If that does
4751  * not work, a target reset will be sent.
4752  *
4753  * Return value:
4754  *      SUCCESS / FAILED
4755  **/
4756 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
4757 {
4758         struct ipr_cmnd *ipr_cmd;
4759         struct ipr_ioa_cfg *ioa_cfg;
4760         struct ipr_resource_entry *res;
4761         struct ata_port *ap;
4762         int rc = 0;
4763
4764         ENTER;
4765         ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
4766         res = scsi_cmd->device->hostdata;
4767
4768         if (!res)
4769                 return FAILED;
4770
4771         /*
4772          * If we are currently going through reset/reload, return failed. This will force the
4773          * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
4774          * reset to complete
4775          */
4776         if (ioa_cfg->in_reset_reload)
4777                 return FAILED;
4778         if (ioa_cfg->ioa_is_dead)
4779                 return FAILED;
4780
4781         list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
4782                 if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
4783                         if (ipr_cmd->scsi_cmd)
4784                                 ipr_cmd->done = ipr_scsi_eh_done;
4785                         if (ipr_cmd->qc)
4786                                 ipr_cmd->done = ipr_sata_eh_done;
4787                         if (ipr_cmd->qc && !(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
4788                                 ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
4789                                 ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
4790                         }
4791                 }
4792         }
4793
4794         res->resetting_device = 1;
4795         scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
4796
4797         if (ipr_is_gata(res) && res->sata_port) {
4798                 ap = res->sata_port->ap;
4799                 spin_unlock_irq(scsi_cmd->device->host->host_lock);
4800                 ata_std_error_handler(ap);
4801                 spin_lock_irq(scsi_cmd->device->host->host_lock);
4802
4803                 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
4804                         if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
4805                                 rc = -EIO;
4806                                 break;
4807                         }
4808                 }
4809         } else
4810                 rc = ipr_device_reset(ioa_cfg, res);
4811         res->resetting_device = 0;
4812
4813         LEAVE;
4814         return rc ? FAILED : SUCCESS;
4815 }
4816
4817 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
4818 {
4819         int rc;
4820
4821         spin_lock_irq(cmd->device->host->host_lock);
4822         rc = __ipr_eh_dev_reset(cmd);
4823         spin_unlock_irq(cmd->device->host->host_lock);
4824
4825         return rc;
4826 }
4827
4828 /**
4829  * ipr_bus_reset_done - Op done function for bus reset.
4830  * @ipr_cmd:    ipr command struct
4831  *
4832  * This function is the op done function for a bus reset
4833  *
4834  * Return value:
4835  *      none
4836  **/
4837 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
4838 {
4839         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4840         struct ipr_resource_entry *res;
4841
4842         ENTER;
4843         if (!ioa_cfg->sis64)
4844                 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4845                         if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
4846                                 scsi_report_bus_reset(ioa_cfg->host, res->bus);
4847                                 break;
4848                         }
4849                 }
4850
4851         /*
4852          * If abort has not completed, indicate the reset has, else call the
4853          * abort's done function to wake the sleeping eh thread
4854          */
4855         if (ipr_cmd->sibling->sibling)
4856                 ipr_cmd->sibling->sibling = NULL;
4857         else
4858                 ipr_cmd->sibling->done(ipr_cmd->sibling);
4859
4860         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4861         LEAVE;
4862 }
4863
4864 /**
4865  * ipr_abort_timeout - An abort task has timed out
4866  * @ipr_cmd:    ipr command struct
4867  *
4868  * This function handles when an abort task times out. If this
4869  * happens we issue a bus reset since we have resources tied
4870  * up that must be freed before returning to the midlayer.
4871  *
4872  * Return value:
4873  *      none
4874  **/
4875 static void ipr_abort_timeout(struct ipr_cmnd *ipr_cmd)
4876 {
4877         struct ipr_cmnd *reset_cmd;
4878         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4879         struct ipr_cmd_pkt *cmd_pkt;
4880         unsigned long lock_flags = 0;
4881
4882         ENTER;
4883         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4884         if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
4885                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4886                 return;
4887         }
4888
4889         sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
4890         reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4891         ipr_cmd->sibling = reset_cmd;
4892         reset_cmd->sibling = ipr_cmd;
4893         reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
4894         cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
4895         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4896         cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
4897         cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
4898
4899         ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
4900         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4901         LEAVE;
4902 }
4903
4904 /**
4905  * ipr_cancel_op - Cancel specified op
4906  * @scsi_cmd:   scsi command struct
4907  *
4908  * This function cancels specified op.
4909  *
4910  * Return value:
4911  *      SUCCESS / FAILED
4912  **/
4913 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
4914 {
4915         struct ipr_cmnd *ipr_cmd;
4916         struct ipr_ioa_cfg *ioa_cfg;
4917         struct ipr_resource_entry *res;
4918         struct ipr_cmd_pkt *cmd_pkt;
4919         u32 ioasc, int_reg;
4920         int op_found = 0;
4921
4922         ENTER;
4923         ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
4924         res = scsi_cmd->device->hostdata;
4925
4926         /* If we are currently going through reset/reload, return failed.
4927          * This will force the mid-layer to call ipr_eh_host_reset,
4928          * which will then go to sleep and wait for the reset to complete
4929          */
4930         if (ioa_cfg->in_reset_reload || ioa_cfg->ioa_is_dead)
4931                 return FAILED;
4932         if (!res)
4933                 return FAILED;
4934
4935         /*
4936          * If we are aborting a timed out op, chances are that the timeout was caused
4937          * by a still not detected EEH error. In such cases, reading a register will
4938          * trigger the EEH recovery infrastructure.
4939          */
4940         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
4941
4942         if (!ipr_is_gscsi(res))
4943                 return FAILED;
4944
4945         list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
4946                 if (ipr_cmd->scsi_cmd == scsi_cmd) {
4947                         ipr_cmd->done = ipr_scsi_eh_done;
4948                         op_found = 1;
4949                         break;
4950                 }
4951         }
4952
4953         if (!op_found)
4954                 return SUCCESS;
4955
4956         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4957         ipr_cmd->ioarcb.res_handle = res->res_handle;
4958         cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
4959         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4960         cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
4961         ipr_cmd->u.sdev = scsi_cmd->device;
4962
4963         scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
4964                     scsi_cmd->cmnd[0]);
4965         ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
4966         ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
4967
4968         /*
4969          * If the abort task timed out and we sent a bus reset, we will get
4970          * one the following responses to the abort
4971          */
4972         if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
4973                 ioasc = 0;
4974                 ipr_trace;
4975         }
4976
4977         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4978         if (!ipr_is_naca_model(res))
4979                 res->needs_sync_complete = 1;
4980
4981         LEAVE;
4982         return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
4983 }
4984
4985 /**
4986  * ipr_eh_abort - Abort a single op
4987  * @scsi_cmd:   scsi command struct
4988  *
4989  * Return value:
4990  *      SUCCESS / FAILED
4991  **/
4992 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
4993 {
4994         unsigned long flags;
4995         int rc;
4996
4997         ENTER;
4998
4999         spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
5000         rc = ipr_cancel_op(scsi_cmd);
5001         spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
5002
5003         LEAVE;
5004         return rc;
5005 }
5006
5007 /**
5008  * ipr_handle_other_interrupt - Handle "other" interrupts
5009  * @ioa_cfg:    ioa config struct
5010  * @int_reg:    interrupt register
5011  *
5012  * Return value:
5013  *      IRQ_NONE / IRQ_HANDLED
5014  **/
5015 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5016                                               u32 int_reg)
5017 {
5018         irqreturn_t rc = IRQ_HANDLED;
5019         u32 int_mask_reg;
5020
5021         int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5022         int_reg &= ~int_mask_reg;
5023
5024         /* If an interrupt on the adapter did not occur, ignore it.
5025          * Or in the case of SIS 64, check for a stage change interrupt.
5026          */
5027         if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
5028                 if (ioa_cfg->sis64) {
5029                         int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5030                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5031                         if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
5032
5033                                 /* clear stage change */
5034                                 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
5035                                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5036                                 list_del(&ioa_cfg->reset_cmd->queue);
5037                                 del_timer(&ioa_cfg->reset_cmd->timer);
5038                                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5039                                 return IRQ_HANDLED;
5040                         }
5041                 }
5042
5043                 return IRQ_NONE;
5044         }
5045
5046         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5047                 /* Mask the interrupt */
5048                 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
5049
5050                 /* Clear the interrupt */
5051                 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.clr_interrupt_reg);
5052                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5053
5054                 list_del(&ioa_cfg->reset_cmd->queue);
5055                 del_timer(&ioa_cfg->reset_cmd->timer);
5056                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5057         } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
5058                 if (ioa_cfg->clear_isr) {
5059                         if (ipr_debug && printk_ratelimit())
5060                                 dev_err(&ioa_cfg->pdev->dev,
5061                                         "Spurious interrupt detected. 0x%08X\n", int_reg);
5062                         writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
5063                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5064                         return IRQ_NONE;
5065                 }
5066         } else {
5067                 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
5068                         ioa_cfg->ioa_unit_checked = 1;
5069                 else
5070                         dev_err(&ioa_cfg->pdev->dev,
5071                                 "Permanent IOA failure. 0x%08X\n", int_reg);
5072
5073                 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5074                         ioa_cfg->sdt_state = GET_DUMP;
5075
5076                 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5077                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5078         }
5079
5080         return rc;
5081 }
5082
5083 /**
5084  * ipr_isr_eh - Interrupt service routine error handler
5085  * @ioa_cfg:    ioa config struct
5086  * @msg:        message to log
5087  *
5088  * Return value:
5089  *      none
5090  **/
5091 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg)
5092 {
5093         ioa_cfg->errors_logged++;
5094         dev_err(&ioa_cfg->pdev->dev, "%s\n", msg);
5095
5096         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5097                 ioa_cfg->sdt_state = GET_DUMP;
5098
5099         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5100 }
5101
5102 /**
5103  * ipr_isr - Interrupt service routine
5104  * @irq:        irq number
5105  * @devp:       pointer to ioa config struct
5106  *
5107  * Return value:
5108  *      IRQ_NONE / IRQ_HANDLED
5109  **/
5110 static irqreturn_t ipr_isr(int irq, void *devp)
5111 {
5112         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
5113         unsigned long lock_flags = 0;
5114         u32 int_reg = 0;
5115         u32 ioasc;
5116         u16 cmd_index;
5117         int num_hrrq = 0;
5118         int irq_none = 0;
5119         struct ipr_cmnd *ipr_cmd;
5120         irqreturn_t rc = IRQ_NONE;
5121
5122         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5123
5124         /* If interrupts are disabled, ignore the interrupt */
5125         if (!ioa_cfg->allow_interrupts) {
5126                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5127                 return IRQ_NONE;
5128         }
5129
5130         while (1) {
5131                 ipr_cmd = NULL;
5132
5133                 while ((be32_to_cpu(*ioa_cfg->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5134                        ioa_cfg->toggle_bit) {
5135
5136                         cmd_index = (be32_to_cpu(*ioa_cfg->hrrq_curr) &
5137                                      IPR_HRRQ_REQ_RESP_HANDLE_MASK) >> IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
5138
5139                         if (unlikely(cmd_index >= IPR_NUM_CMD_BLKS)) {
5140                                 ipr_isr_eh(ioa_cfg, "Invalid response handle from IOA");
5141                                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5142                                 return IRQ_HANDLED;
5143                         }
5144
5145                         ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
5146
5147                         ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5148
5149                         ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
5150
5151                         list_del(&ipr_cmd->queue);
5152                         del_timer(&ipr_cmd->timer);
5153                         ipr_cmd->done(ipr_cmd);
5154
5155                         rc = IRQ_HANDLED;
5156
5157                         if (ioa_cfg->hrrq_curr < ioa_cfg->hrrq_end) {
5158                                 ioa_cfg->hrrq_curr++;
5159                         } else {
5160                                 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
5161                                 ioa_cfg->toggle_bit ^= 1u;
5162                         }
5163                 }
5164
5165                 if (ipr_cmd && !ioa_cfg->clear_isr)
5166                         break;
5167
5168                 if (ipr_cmd != NULL) {
5169                         /* Clear the PCI interrupt */
5170                         num_hrrq = 0;
5171                         do {
5172                                 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
5173                                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5174                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
5175                                         num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
5176
5177                 } else if (rc == IRQ_NONE && irq_none == 0) {
5178                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5179                         irq_none++;
5180                 } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
5181                            int_reg & IPR_PCII_HRRQ_UPDATED) {
5182                         ipr_isr_eh(ioa_cfg, "Error clearing HRRQ");
5183                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5184                         return IRQ_HANDLED;
5185                 } else
5186                         break;
5187         }
5188
5189         if (unlikely(rc == IRQ_NONE))
5190                 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
5191
5192         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5193         return rc;
5194 }
5195
5196 /**
5197  * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5198  * @ioa_cfg:    ioa config struct
5199  * @ipr_cmd:    ipr command struct
5200  *
5201  * Return value:
5202  *      0 on success / -1 on failure
5203  **/
5204 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
5205                              struct ipr_cmnd *ipr_cmd)
5206 {
5207         int i, nseg;
5208         struct scatterlist *sg;
5209         u32 length;
5210         u32 ioadl_flags = 0;
5211         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5212         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5213         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
5214
5215         length = scsi_bufflen(scsi_cmd);
5216         if (!length)
5217                 return 0;
5218
5219         nseg = scsi_dma_map(scsi_cmd);
5220         if (nseg < 0) {
5221                 if (printk_ratelimit())
5222                         dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
5223                 return -1;
5224         }
5225
5226         ipr_cmd->dma_use_sg = nseg;
5227
5228         ioarcb->data_transfer_length = cpu_to_be32(length);
5229         ioarcb->ioadl_len =
5230                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
5231
5232         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5233                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5234                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5235         } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
5236                 ioadl_flags = IPR_IOADL_FLAGS_READ;
5237
5238         scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
5239                 ioadl64[i].flags = cpu_to_be32(ioadl_flags);
5240                 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
5241                 ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
5242         }
5243
5244         ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5245         return 0;
5246 }
5247
5248 /**
5249  * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5250  * @ioa_cfg:    ioa config struct
5251  * @ipr_cmd:    ipr command struct
5252  *
5253  * Return value:
5254  *      0 on success / -1 on failure
5255  **/
5256 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
5257                            struct ipr_cmnd *ipr_cmd)
5258 {
5259         int i, nseg;
5260         struct scatterlist *sg;
5261         u32 length;
5262         u32 ioadl_flags = 0;
5263         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5264         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5265         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
5266
5267         length = scsi_bufflen(scsi_cmd);
5268         if (!length)
5269                 return 0;
5270
5271         nseg = scsi_dma_map(scsi_cmd);
5272         if (nseg < 0) {
5273                 dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
5274                 return -1;
5275         }
5276
5277         ipr_cmd->dma_use_sg = nseg;
5278
5279         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5280                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5281                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5282                 ioarcb->data_transfer_length = cpu_to_be32(length);
5283                 ioarcb->ioadl_len =
5284                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
5285         } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
5286                 ioadl_flags = IPR_IOADL_FLAGS_READ;
5287                 ioarcb->read_data_transfer_length = cpu_to_be32(length);
5288                 ioarcb->read_ioadl_len =
5289                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
5290         }
5291
5292         if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
5293                 ioadl = ioarcb->u.add_data.u.ioadl;
5294                 ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
5295                                     offsetof(struct ipr_ioarcb, u.add_data));
5296                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
5297         }
5298
5299         scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
5300                 ioadl[i].flags_and_data_len =
5301                         cpu_to_be32(ioadl_flags | sg_dma_len(sg));
5302                 ioadl[i].address = cpu_to_be32(sg_dma_address(sg));
5303         }
5304
5305         ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5306         return 0;
5307 }
5308
5309 /**
5310  * ipr_get_task_attributes - Translate SPI Q-Tag to task attributes
5311  * @scsi_cmd:   scsi command struct
5312  *
5313  * Return value:
5314  *      task attributes
5315  **/
5316 static u8 ipr_get_task_attributes(struct scsi_cmnd *scsi_cmd)
5317 {
5318         u8 tag[2];
5319         u8 rc = IPR_FLAGS_LO_UNTAGGED_TASK;
5320
5321         if (scsi_populate_tag_msg(scsi_cmd, tag)) {
5322                 switch (tag[0]) {
5323                 case MSG_SIMPLE_TAG:
5324                         rc = IPR_FLAGS_LO_SIMPLE_TASK;
5325                         break;
5326                 case MSG_HEAD_TAG:
5327                         rc = IPR_FLAGS_LO_HEAD_OF_Q_TASK;
5328                         break;
5329                 case MSG_ORDERED_TAG:
5330                         rc = IPR_FLAGS_LO_ORDERED_TASK;
5331                         break;
5332                 };
5333         }
5334
5335         return rc;
5336 }
5337
5338 /**
5339  * ipr_erp_done - Process completion of ERP for a device
5340  * @ipr_cmd:            ipr command struct
5341  *
5342  * This function copies the sense buffer into the scsi_cmd
5343  * struct and pushes the scsi_done function.
5344  *
5345  * Return value:
5346  *      nothing
5347  **/
5348 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
5349 {
5350         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5351         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
5352         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5353         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5354
5355         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
5356                 scsi_cmd->result |= (DID_ERROR << 16);
5357                 scmd_printk(KERN_ERR, scsi_cmd,
5358                             "Request Sense failed with IOASC: 0x%08X\n", ioasc);
5359         } else {
5360                 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
5361                        SCSI_SENSE_BUFFERSIZE);
5362         }
5363
5364         if (res) {
5365                 if (!ipr_is_naca_model(res))
5366                         res->needs_sync_complete = 1;
5367                 res->in_erp = 0;
5368         }
5369         scsi_dma_unmap(ipr_cmd->scsi_cmd);
5370         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5371         scsi_cmd->scsi_done(scsi_cmd);
5372 }
5373
5374 /**
5375  * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
5376  * @ipr_cmd:    ipr command struct
5377  *
5378  * Return value:
5379  *      none
5380  **/
5381 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
5382 {
5383         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5384         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
5385         dma_addr_t dma_addr = ipr_cmd->dma_addr;
5386
5387         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
5388         ioarcb->data_transfer_length = 0;
5389         ioarcb->read_data_transfer_length = 0;
5390         ioarcb->ioadl_len = 0;
5391         ioarcb->read_ioadl_len = 0;
5392         ioasa->hdr.ioasc = 0;
5393         ioasa->hdr.residual_data_len = 0;
5394
5395         if (ipr_cmd->ioa_cfg->sis64)
5396                 ioarcb->u.sis64_addr_data.data_ioadl_addr =
5397                         cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
5398         else {
5399                 ioarcb->write_ioadl_addr =
5400                         cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
5401                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
5402         }
5403 }
5404
5405 /**
5406  * ipr_erp_request_sense - Send request sense to a device
5407  * @ipr_cmd:    ipr command struct
5408  *
5409  * This function sends a request sense to a device as a result
5410  * of a check condition.
5411  *
5412  * Return value:
5413  *      nothing
5414  **/
5415 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
5416 {
5417         struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5418         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5419
5420         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
5421                 ipr_erp_done(ipr_cmd);
5422                 return;
5423         }
5424
5425         ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
5426
5427         cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
5428         cmd_pkt->cdb[0] = REQUEST_SENSE;
5429         cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
5430         cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
5431         cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
5432         cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
5433
5434         ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
5435                        SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
5436
5437         ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
5438                    IPR_REQUEST_SENSE_TIMEOUT * 2);
5439 }
5440
5441 /**
5442  * ipr_erp_cancel_all - Send cancel all to a device
5443  * @ipr_cmd:    ipr command struct
5444  *
5445  * This function sends a cancel all to a device to clear the
5446  * queue. If we are running TCQ on the device, QERR is set to 1,
5447  * which means all outstanding ops have been dropped on the floor.
5448  * Cancel all will return them to us.
5449  *
5450  * Return value:
5451  *      nothing
5452  **/
5453 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
5454 {
5455         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5456         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
5457         struct ipr_cmd_pkt *cmd_pkt;
5458
5459         res->in_erp = 1;
5460
5461         ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
5462
5463         if (!scsi_get_tag_type(scsi_cmd->device)) {
5464                 ipr_erp_request_sense(ipr_cmd);
5465                 return;
5466         }
5467
5468         cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5469         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5470         cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
5471
5472         ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
5473                    IPR_CANCEL_ALL_TIMEOUT);
5474 }
5475
5476 /**
5477  * ipr_dump_ioasa - Dump contents of IOASA
5478  * @ioa_cfg:    ioa config struct
5479  * @ipr_cmd:    ipr command struct
5480  * @res:                resource entry struct
5481  *
5482  * This function is invoked by the interrupt handler when ops
5483  * fail. It will log the IOASA if appropriate. Only called
5484  * for GPDD ops.
5485  *
5486  * Return value:
5487  *      none
5488  **/
5489 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
5490                            struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
5491 {
5492         int i;
5493         u16 data_len;
5494         u32 ioasc, fd_ioasc;
5495         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
5496         __be32 *ioasa_data = (__be32 *)ioasa;
5497         int error_index;
5498
5499         ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
5500         fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
5501
5502         if (0 == ioasc)
5503                 return;
5504
5505         if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
5506                 return;
5507
5508         if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
5509                 error_index = ipr_get_error(fd_ioasc);
5510         else
5511                 error_index = ipr_get_error(ioasc);
5512
5513         if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
5514                 /* Don't log an error if the IOA already logged one */
5515                 if (ioasa->hdr.ilid != 0)
5516                         return;
5517
5518                 if (!ipr_is_gscsi(res))
5519                         return;
5520
5521                 if (ipr_error_table[error_index].log_ioasa == 0)
5522                         return;
5523         }
5524
5525         ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
5526
5527         data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
5528         if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
5529                 data_len = sizeof(struct ipr_ioasa64);
5530         else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
5531                 data_len = sizeof(struct ipr_ioasa);
5532
5533         ipr_err("IOASA Dump:\n");
5534
5535         for (i = 0; i < data_len / 4; i += 4) {
5536                 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
5537                         be32_to_cpu(ioasa_data[i]),
5538                         be32_to_cpu(ioasa_data[i+1]),
5539                         be32_to_cpu(ioasa_data[i+2]),
5540                         be32_to_cpu(ioasa_data[i+3]));
5541         }
5542 }
5543
5544 /**
5545  * ipr_gen_sense - Generate SCSI sense data from an IOASA
5546  * @ioasa:              IOASA
5547  * @sense_buf:  sense data buffer
5548  *
5549  * Return value:
5550  *      none
5551  **/
5552 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
5553 {
5554         u32 failing_lba;
5555         u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
5556         struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
5557         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
5558         u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
5559
5560         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
5561
5562         if (ioasc >= IPR_FIRST_DRIVER_IOASC)
5563                 return;
5564
5565         ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
5566
5567         if (ipr_is_vset_device(res) &&
5568             ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
5569             ioasa->u.vset.failing_lba_hi != 0) {
5570                 sense_buf[0] = 0x72;
5571                 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
5572                 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
5573                 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
5574
5575                 sense_buf[7] = 12;
5576                 sense_buf[8] = 0;
5577                 sense_buf[9] = 0x0A;
5578                 sense_buf[10] = 0x80;
5579
5580                 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
5581
5582                 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
5583                 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
5584                 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
5585                 sense_buf[15] = failing_lba & 0x000000ff;
5586
5587                 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
5588
5589                 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
5590                 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
5591                 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
5592                 sense_buf[19] = failing_lba & 0x000000ff;
5593         } else {
5594                 sense_buf[0] = 0x70;
5595                 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
5596                 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
5597                 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
5598
5599                 /* Illegal request */
5600                 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
5601                     (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
5602                         sense_buf[7] = 10;      /* additional length */
5603
5604                         /* IOARCB was in error */
5605                         if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
5606                                 sense_buf[15] = 0xC0;
5607                         else    /* Parameter data was invalid */
5608                                 sense_buf[15] = 0x80;
5609
5610                         sense_buf[16] =
5611                             ((IPR_FIELD_POINTER_MASK &
5612                               be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
5613                         sense_buf[17] =
5614                             (IPR_FIELD_POINTER_MASK &
5615                              be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
5616                 } else {
5617                         if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
5618                                 if (ipr_is_vset_device(res))
5619                                         failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
5620                                 else
5621                                         failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
5622
5623                                 sense_buf[0] |= 0x80;   /* Or in the Valid bit */
5624                                 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
5625                                 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
5626                                 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
5627                                 sense_buf[6] = failing_lba & 0x000000ff;
5628                         }
5629
5630                         sense_buf[7] = 6;       /* additional length */
5631                 }
5632         }
5633 }
5634
5635 /**
5636  * ipr_get_autosense - Copy autosense data to sense buffer
5637  * @ipr_cmd:    ipr command struct
5638  *
5639  * This function copies the autosense buffer to the buffer
5640  * in the scsi_cmd, if there is autosense available.
5641  *
5642  * Return value:
5643  *      1 if autosense was available / 0 if not
5644  **/
5645 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
5646 {
5647         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
5648         struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
5649
5650         if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
5651                 return 0;
5652
5653         if (ipr_cmd->ioa_cfg->sis64)
5654                 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
5655                        min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
5656                            SCSI_SENSE_BUFFERSIZE));
5657         else
5658                 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
5659                        min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
5660                            SCSI_SENSE_BUFFERSIZE));
5661         return 1;
5662 }
5663
5664 /**
5665  * ipr_erp_start - Process an error response for a SCSI op
5666  * @ioa_cfg:    ioa config struct
5667  * @ipr_cmd:    ipr command struct
5668  *
5669  * This function determines whether or not to initiate ERP
5670  * on the affected device.
5671  *
5672  * Return value:
5673  *      nothing
5674  **/
5675 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
5676                               struct ipr_cmnd *ipr_cmd)
5677 {
5678         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5679         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
5680         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5681         u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
5682
5683         if (!res) {
5684                 ipr_scsi_eh_done(ipr_cmd);
5685                 return;
5686         }
5687
5688         if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
5689                 ipr_gen_sense(ipr_cmd);
5690
5691         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
5692
5693         switch (masked_ioasc) {
5694         case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
5695                 if (ipr_is_naca_model(res))
5696                         scsi_cmd->result |= (DID_ABORT << 16);
5697                 else
5698                         scsi_cmd->result |= (DID_IMM_RETRY << 16);
5699                 break;
5700         case IPR_IOASC_IR_RESOURCE_HANDLE:
5701         case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
5702                 scsi_cmd->result |= (DID_NO_CONNECT << 16);
5703                 break;
5704         case IPR_IOASC_HW_SEL_TIMEOUT:
5705                 scsi_cmd->result |= (DID_NO_CONNECT << 16);
5706                 if (!ipr_is_naca_model(res))
5707                         res->needs_sync_complete = 1;
5708                 break;
5709         case IPR_IOASC_SYNC_REQUIRED:
5710                 if (!res->in_erp)
5711                         res->needs_sync_complete = 1;
5712                 scsi_cmd->result |= (DID_IMM_RETRY << 16);
5713                 break;
5714         case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
5715         case IPR_IOASA_IR_DUAL_IOA_DISABLED:
5716                 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
5717                 break;
5718         case IPR_IOASC_BUS_WAS_RESET:
5719         case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
5720                 /*
5721                  * Report the bus reset and ask for a retry. The device
5722                  * will give CC/UA the next command.
5723                  */
5724                 if (!res->resetting_device)
5725                         scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
5726                 scsi_cmd->result |= (DID_ERROR << 16);
5727                 if (!ipr_is_naca_model(res))
5728                         res->needs_sync_complete = 1;
5729                 break;
5730         case IPR_IOASC_HW_DEV_BUS_STATUS:
5731                 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
5732                 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
5733                         if (!ipr_get_autosense(ipr_cmd)) {
5734                                 if (!ipr_is_naca_model(res)) {
5735                                         ipr_erp_cancel_all(ipr_cmd);
5736                                         return;
5737                                 }
5738                         }
5739                 }
5740                 if (!ipr_is_naca_model(res))
5741                         res->needs_sync_complete = 1;
5742                 break;
5743         case IPR_IOASC_NR_INIT_CMD_REQUIRED:
5744                 break;
5745         default:
5746                 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
5747                         scsi_cmd->result |= (DID_ERROR << 16);
5748                 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
5749                         res->needs_sync_complete = 1;
5750                 break;
5751         }
5752
5753         scsi_dma_unmap(ipr_cmd->scsi_cmd);
5754         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5755         scsi_cmd->scsi_done(scsi_cmd);
5756 }
5757
5758 /**
5759  * ipr_scsi_done - mid-layer done function
5760  * @ipr_cmd:    ipr command struct
5761  *
5762  * This function is invoked by the interrupt handler for
5763  * ops generated by the SCSI mid-layer
5764  *
5765  * Return value:
5766  *      none
5767  **/
5768 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
5769 {
5770         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5771         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5772         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5773
5774         scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
5775
5776         if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
5777                 scsi_dma_unmap(ipr_cmd->scsi_cmd);
5778                 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5779                 scsi_cmd->scsi_done(scsi_cmd);
5780         } else
5781                 ipr_erp_start(ioa_cfg, ipr_cmd);
5782 }
5783
5784 /**
5785  * ipr_queuecommand - Queue a mid-layer request
5786  * @scsi_cmd:   scsi command struct
5787  * @done:               done function
5788  *
5789  * This function queues a request generated by the mid-layer.
5790  *
5791  * Return value:
5792  *      0 on success
5793  *      SCSI_MLQUEUE_DEVICE_BUSY if device is busy
5794  *      SCSI_MLQUEUE_HOST_BUSY if host is busy
5795  **/
5796 static int ipr_queuecommand_lck(struct scsi_cmnd *scsi_cmd,
5797                             void (*done) (struct scsi_cmnd *))
5798 {
5799         struct ipr_ioa_cfg *ioa_cfg;
5800         struct ipr_resource_entry *res;
5801         struct ipr_ioarcb *ioarcb;
5802         struct ipr_cmnd *ipr_cmd;
5803         int rc = 0;
5804
5805         scsi_cmd->scsi_done = done;
5806         ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5807         res = scsi_cmd->device->hostdata;
5808         scsi_cmd->result = (DID_OK << 16);
5809
5810         /*
5811          * We are currently blocking all devices due to a host reset
5812          * We have told the host to stop giving us new requests, but
5813          * ERP ops don't count. FIXME
5814          */
5815         if (unlikely(!ioa_cfg->allow_cmds && !ioa_cfg->ioa_is_dead))
5816                 return SCSI_MLQUEUE_HOST_BUSY;
5817
5818         /*
5819          * FIXME - Create scsi_set_host_offline interface
5820          *  and the ioa_is_dead check can be removed
5821          */
5822         if (unlikely(ioa_cfg->ioa_is_dead || !res)) {
5823                 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
5824                 scsi_cmd->result = (DID_NO_CONNECT << 16);
5825                 scsi_cmd->scsi_done(scsi_cmd);
5826                 return 0;
5827         }
5828
5829         if (ipr_is_gata(res) && res->sata_port)
5830                 return ata_sas_queuecmd(scsi_cmd, res->sata_port->ap);
5831
5832         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5833         ioarcb = &ipr_cmd->ioarcb;
5834         list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
5835
5836         memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
5837         ipr_cmd->scsi_cmd = scsi_cmd;
5838         ioarcb->res_handle = res->res_handle;
5839         ipr_cmd->done = ipr_scsi_done;
5840         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
5841
5842         if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
5843                 if (scsi_cmd->underflow == 0)
5844                         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
5845
5846                 if (res->needs_sync_complete) {
5847                         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
5848                         res->needs_sync_complete = 0;
5849                 }
5850
5851                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
5852                 if (ipr_is_gscsi(res))
5853                         ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
5854                 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
5855                 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
5856         }
5857
5858         if (scsi_cmd->cmnd[0] >= 0xC0 &&
5859             (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
5860                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5861
5862         if (likely(rc == 0)) {
5863                 if (ioa_cfg->sis64)
5864                         rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
5865                 else
5866                         rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
5867         }
5868
5869         if (unlikely(rc != 0)) {
5870                 list_move_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5871                 return SCSI_MLQUEUE_HOST_BUSY;
5872         }
5873
5874         ipr_send_command(ipr_cmd);
5875         return 0;
5876 }
5877
5878 static DEF_SCSI_QCMD(ipr_queuecommand)
5879
5880 /**
5881  * ipr_ioctl - IOCTL handler
5882  * @sdev:       scsi device struct
5883  * @cmd:        IOCTL cmd
5884  * @arg:        IOCTL arg
5885  *
5886  * Return value:
5887  *      0 on success / other on failure
5888  **/
5889 static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
5890 {
5891         struct ipr_resource_entry *res;
5892
5893         res = (struct ipr_resource_entry *)sdev->hostdata;
5894         if (res && ipr_is_gata(res)) {
5895                 if (cmd == HDIO_GET_IDENTITY)
5896                         return -ENOTTY;
5897                 return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
5898         }
5899
5900         return -EINVAL;
5901 }
5902
5903 /**
5904  * ipr_info - Get information about the card/driver
5905  * @scsi_host:  scsi host struct
5906  *
5907  * Return value:
5908  *      pointer to buffer with description string
5909  **/
5910 static const char *ipr_ioa_info(struct Scsi_Host *host)
5911 {
5912         static char buffer[512];
5913         struct ipr_ioa_cfg *ioa_cfg;
5914         unsigned long lock_flags = 0;
5915
5916         ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
5917
5918         spin_lock_irqsave(host->host_lock, lock_flags);
5919         sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
5920         spin_unlock_irqrestore(host->host_lock, lock_flags);
5921
5922         return buffer;
5923 }
5924
5925 static struct scsi_host_template driver_template = {
5926         .module = THIS_MODULE,
5927         .name = "IPR",
5928         .info = ipr_ioa_info,
5929         .ioctl = ipr_ioctl,
5930         .queuecommand = ipr_queuecommand,
5931         .eh_abort_handler = ipr_eh_abort,
5932         .eh_device_reset_handler = ipr_eh_dev_reset,
5933         .eh_host_reset_handler = ipr_eh_host_reset,
5934         .slave_alloc = ipr_slave_alloc,
5935         .slave_configure = ipr_slave_configure,
5936         .slave_destroy = ipr_slave_destroy,
5937         .target_alloc = ipr_target_alloc,
5938         .target_destroy = ipr_target_destroy,
5939         .change_queue_depth = ipr_change_queue_depth,
5940         .change_queue_type = ipr_change_queue_type,
5941         .bios_param = ipr_biosparam,
5942         .can_queue = IPR_MAX_COMMANDS,
5943         .this_id = -1,
5944         .sg_tablesize = IPR_MAX_SGLIST,
5945         .max_sectors = IPR_IOA_MAX_SECTORS,
5946         .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
5947         .use_clustering = ENABLE_CLUSTERING,
5948         .shost_attrs = ipr_ioa_attrs,
5949         .sdev_attrs = ipr_dev_attrs,
5950         .proc_name = IPR_NAME
5951 };
5952
5953 /**
5954  * ipr_ata_phy_reset - libata phy_reset handler
5955  * @ap:         ata port to reset
5956  *
5957  **/
5958 static void ipr_ata_phy_reset(struct ata_port *ap)
5959 {
5960         unsigned long flags;
5961         struct ipr_sata_port *sata_port = ap->private_data;
5962         struct ipr_resource_entry *res = sata_port->res;
5963         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
5964         int rc;
5965
5966         ENTER;
5967         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5968         while (ioa_cfg->in_reset_reload) {
5969                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5970                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5971                 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5972         }
5973
5974         if (!ioa_cfg->allow_cmds)
5975                 goto out_unlock;
5976
5977         rc = ipr_device_reset(ioa_cfg, res);
5978
5979         if (rc) {
5980                 ap->link.device[0].class = ATA_DEV_NONE;
5981                 goto out_unlock;
5982         }
5983
5984         ap->link.device[0].class = res->ata_class;
5985         if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
5986                 ap->link.device[0].class = ATA_DEV_NONE;
5987
5988 out_unlock:
5989         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5990         LEAVE;
5991 }
5992
5993 /**
5994  * ipr_ata_post_internal - Cleanup after an internal command
5995  * @qc: ATA queued command
5996  *
5997  * Return value:
5998  *      none
5999  **/
6000 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
6001 {
6002         struct ipr_sata_port *sata_port = qc->ap->private_data;
6003         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6004         struct ipr_cmnd *ipr_cmd;
6005         unsigned long flags;
6006
6007         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6008         while (ioa_cfg->in_reset_reload) {
6009                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6010                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6011                 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6012         }
6013
6014         list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
6015                 if (ipr_cmd->qc == qc) {
6016                         ipr_device_reset(ioa_cfg, sata_port->res);
6017                         break;
6018                 }
6019         }
6020         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6021 }
6022
6023 /**
6024  * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6025  * @regs:       destination
6026  * @tf: source ATA taskfile
6027  *
6028  * Return value:
6029  *      none
6030  **/
6031 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
6032                              struct ata_taskfile *tf)
6033 {
6034         regs->feature = tf->feature;
6035         regs->nsect = tf->nsect;
6036         regs->lbal = tf->lbal;
6037         regs->lbam = tf->lbam;
6038         regs->lbah = tf->lbah;
6039         regs->device = tf->device;
6040         regs->command = tf->command;
6041         regs->hob_feature = tf->hob_feature;
6042         regs->hob_nsect = tf->hob_nsect;
6043         regs->hob_lbal = tf->hob_lbal;
6044         regs->hob_lbam = tf->hob_lbam;
6045         regs->hob_lbah = tf->hob_lbah;
6046         regs->ctl = tf->ctl;
6047 }
6048
6049 /**
6050  * ipr_sata_done - done function for SATA commands
6051  * @ipr_cmd:    ipr command struct
6052  *
6053  * This function is invoked by the interrupt handler for
6054  * ops generated by the SCSI mid-layer to SATA devices
6055  *
6056  * Return value:
6057  *      none
6058  **/
6059 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
6060 {
6061         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6062         struct ata_queued_cmd *qc = ipr_cmd->qc;
6063         struct ipr_sata_port *sata_port = qc->ap->private_data;
6064         struct ipr_resource_entry *res = sata_port->res;
6065         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6066
6067         if (ipr_cmd->ioa_cfg->sis64)
6068                 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
6069                        sizeof(struct ipr_ioasa_gata));
6070         else
6071                 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
6072                        sizeof(struct ipr_ioasa_gata));
6073         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6074
6075         if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
6076                 scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
6077
6078         if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6079                 qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
6080         else
6081                 qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
6082         list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
6083         ata_qc_complete(qc);
6084 }
6085
6086 /**
6087  * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6088  * @ipr_cmd:    ipr command struct
6089  * @qc:         ATA queued command
6090  *
6091  **/
6092 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
6093                                   struct ata_queued_cmd *qc)
6094 {
6095         u32 ioadl_flags = 0;
6096         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6097         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
6098         struct ipr_ioadl64_desc *last_ioadl64 = NULL;
6099         int len = qc->nbytes;
6100         struct scatterlist *sg;
6101         unsigned int si;
6102         dma_addr_t dma_addr = ipr_cmd->dma_addr;
6103
6104         if (len == 0)
6105                 return;
6106
6107         if (qc->dma_dir == DMA_TO_DEVICE) {
6108                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6109                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6110         } else if (qc->dma_dir == DMA_FROM_DEVICE)
6111                 ioadl_flags = IPR_IOADL_FLAGS_READ;
6112
6113         ioarcb->data_transfer_length = cpu_to_be32(len);
6114         ioarcb->ioadl_len =
6115                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
6116         ioarcb->u.sis64_addr_data.data_ioadl_addr =
6117                 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl));
6118
6119         for_each_sg(qc->sg, sg, qc->n_elem, si) {
6120                 ioadl64->flags = cpu_to_be32(ioadl_flags);
6121                 ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
6122                 ioadl64->address = cpu_to_be64(sg_dma_address(sg));
6123
6124                 last_ioadl64 = ioadl64;
6125                 ioadl64++;
6126         }
6127
6128         if (likely(last_ioadl64))
6129                 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6130 }
6131
6132 /**
6133  * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6134  * @ipr_cmd:    ipr command struct
6135  * @qc:         ATA queued command
6136  *
6137  **/
6138 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
6139                                 struct ata_queued_cmd *qc)
6140 {
6141         u32 ioadl_flags = 0;
6142         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6143         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
6144         struct ipr_ioadl_desc *last_ioadl = NULL;
6145         int len = qc->nbytes;
6146         struct scatterlist *sg;
6147         unsigned int si;
6148
6149         if (len == 0)
6150                 return;
6151
6152         if (qc->dma_dir == DMA_TO_DEVICE) {
6153                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6154                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6155                 ioarcb->data_transfer_length = cpu_to_be32(len);
6156                 ioarcb->ioadl_len =
6157                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6158         } else if (qc->dma_dir == DMA_FROM_DEVICE) {
6159                 ioadl_flags = IPR_IOADL_FLAGS_READ;
6160                 ioarcb->read_data_transfer_length = cpu_to_be32(len);
6161                 ioarcb->read_ioadl_len =
6162                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6163         }
6164
6165         for_each_sg(qc->sg, sg, qc->n_elem, si) {
6166                 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6167                 ioadl->address = cpu_to_be32(sg_dma_address(sg));
6168
6169                 last_ioadl = ioadl;
6170                 ioadl++;
6171         }
6172
6173         if (likely(last_ioadl))
6174                 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6175 }
6176
6177 /**
6178  * ipr_qc_issue - Issue a SATA qc to a device
6179  * @qc: queued command
6180  *
6181  * Return value:
6182  *      0 if success
6183  **/
6184 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
6185 {
6186         struct ata_port *ap = qc->ap;
6187         struct ipr_sata_port *sata_port = ap->private_data;
6188         struct ipr_resource_entry *res = sata_port->res;
6189         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6190         struct ipr_cmnd *ipr_cmd;
6191         struct ipr_ioarcb *ioarcb;
6192         struct ipr_ioarcb_ata_regs *regs;
6193
6194         if (unlikely(!ioa_cfg->allow_cmds || ioa_cfg->ioa_is_dead))
6195                 return AC_ERR_SYSTEM;
6196
6197         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
6198         ioarcb = &ipr_cmd->ioarcb;
6199
6200         if (ioa_cfg->sis64) {
6201                 regs = &ipr_cmd->i.ata_ioadl.regs;
6202                 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
6203         } else
6204                 regs = &ioarcb->u.add_data.u.regs;
6205
6206         memset(regs, 0, sizeof(*regs));
6207         ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
6208
6209         list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
6210         ipr_cmd->qc = qc;
6211         ipr_cmd->done = ipr_sata_done;
6212         ipr_cmd->ioarcb.res_handle = res->res_handle;
6213         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
6214         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
6215         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6216         ipr_cmd->dma_use_sg = qc->n_elem;
6217
6218         if (ioa_cfg->sis64)
6219                 ipr_build_ata_ioadl64(ipr_cmd, qc);
6220         else
6221                 ipr_build_ata_ioadl(ipr_cmd, qc);
6222
6223         regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
6224         ipr_copy_sata_tf(regs, &qc->tf);
6225         memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
6226         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
6227
6228         switch (qc->tf.protocol) {
6229         case ATA_PROT_NODATA:
6230         case ATA_PROT_PIO:
6231                 break;
6232
6233         case ATA_PROT_DMA:
6234                 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
6235                 break;
6236
6237         case ATAPI_PROT_PIO:
6238         case ATAPI_PROT_NODATA:
6239                 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
6240                 break;
6241
6242         case ATAPI_PROT_DMA:
6243                 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
6244                 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
6245                 break;
6246
6247         default:
6248                 WARN_ON(1);
6249                 return AC_ERR_INVALID;
6250         }
6251
6252         ipr_send_command(ipr_cmd);
6253
6254         return 0;
6255<