drivers/scsi/ipr.c

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