Version:  2.0.40 2.2.26 2.4.37 3.2 3.3 3.4 3.5 3.6 3.7 3.8 3.9 3.10 3.11 3.12 3.13 3.14 3.15 3.16 3.17 3.18

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