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