drivers/scsi/ipr.c

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