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