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