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