git.oblomov.eu Git - linux-2.6/blob - drivers/scsi/ipr.c

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