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