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