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