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