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