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