drivers/scsi/ipr.c

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