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