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