drivers/scsi/ipr.c

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