drivers/scsi/ipr.c

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