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