drivers/scsi/ipr.c

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