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