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