Version:  2.0.40 2.2.26 2.4.37 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18 3.19 4.0 4.1 4.2 4.3 4.4 4.5 4.6 4.7

Linux/drivers/scsi/ipr.c

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