drivers/scsi/ipr.c

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