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_sis64_service_required_error - Log a sis64 service required error.
2416  * @ioa_cfg:    ioa config struct
2417  * @hostrcb:    hostrcb struct
2418  *
2419  * Return value:
2420  *      none
2421  **/
2422 static void ipr_log_sis64_service_required_error(struct ipr_ioa_cfg *ioa_cfg,
2423                                        struct ipr_hostrcb *hostrcb)
2424 {
2425         struct ipr_hostrcb_type_41_error *error;
2426
2427         error = &hostrcb->hcam.u.error64.u.type_41_error;
2428
2429         error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2430         ipr_err("Primary Failure Reason: %s\n", error->failure_reason);
2431         ipr_log_hex_data(ioa_cfg, error->data,
2432                          be32_to_cpu(hostrcb->hcam.length) -
2433                          (offsetof(struct ipr_hostrcb_error, u) +
2434                           offsetof(struct ipr_hostrcb_type_41_error, data)));
2435 }
2436 /**
2437  * ipr_log_generic_error - Log an adapter error.
2438  * @ioa_cfg:    ioa config struct
2439  * @hostrcb:    hostrcb struct
2440  *
2441  * Return value:
2442  *      none
2443  **/
2444 static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2445                                   struct ipr_hostrcb *hostrcb)
2446 {
2447         ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2448                          be32_to_cpu(hostrcb->hcam.length));
2449 }
2450
2451 /**
2452  * ipr_log_sis64_device_error - Log a cache error.
2453  * @ioa_cfg:    ioa config struct
2454  * @hostrcb:    hostrcb struct
2455  *
2456  * Return value:
2457  *      none
2458  **/
2459 static void ipr_log_sis64_device_error(struct ipr_ioa_cfg *ioa_cfg,
2460                                          struct ipr_hostrcb *hostrcb)
2461 {
2462         struct ipr_hostrcb_type_21_error *error;
2463         char buffer[IPR_MAX_RES_PATH_LENGTH];
2464
2465         error = &hostrcb->hcam.u.error64.u.type_21_error;
2466
2467         ipr_err("-----Failing Device Information-----\n");
2468         ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
2469                 be32_to_cpu(error->wwn[0]), be32_to_cpu(error->wwn[1]),
2470                  be32_to_cpu(error->wwn[2]), be32_to_cpu(error->wwn[3]));
2471         ipr_err("Device Resource Path: %s\n",
2472                 __ipr_format_res_path(error->res_path,
2473                                       buffer, sizeof(buffer)));
2474         error->primary_problem_desc[sizeof(error->primary_problem_desc) - 1] = '\0';
2475         error->second_problem_desc[sizeof(error->second_problem_desc) - 1] = '\0';
2476         ipr_err("Primary Problem Description: %s\n", error->primary_problem_desc);
2477         ipr_err("Secondary Problem Description:  %s\n", error->second_problem_desc);
2478         ipr_err("SCSI Sense Data:\n");
2479         ipr_log_hex_data(ioa_cfg, error->sense_data, sizeof(error->sense_data));
2480         ipr_err("SCSI Command Descriptor Block: \n");
2481         ipr_log_hex_data(ioa_cfg, error->cdb, sizeof(error->cdb));
2482
2483         ipr_err("Additional IOA Data:\n");
2484         ipr_log_hex_data(ioa_cfg, error->ioa_data, be32_to_cpu(error->length_of_error));
2485 }
2486
2487 /**
2488  * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2489  * @ioasc:      IOASC
2490  *
2491  * This function will return the index of into the ipr_error_table
2492  * for the specified IOASC. If the IOASC is not in the table,
2493  * 0 will be returned, which points to the entry used for unknown errors.
2494  *
2495  * Return value:
2496  *      index into the ipr_error_table
2497  **/
2498 static u32 ipr_get_error(u32 ioasc)
2499 {
2500         int i;
2501
2502         for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2503                 if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2504                         return i;
2505
2506         return 0;
2507 }
2508
2509 /**
2510  * ipr_handle_log_data - Log an adapter error.
2511  * @ioa_cfg:    ioa config struct
2512  * @hostrcb:    hostrcb struct
2513  *
2514  * This function logs an adapter error to the system.
2515  *
2516  * Return value:
2517  *      none
2518  **/
2519 static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2520                                 struct ipr_hostrcb *hostrcb)
2521 {
2522         u32 ioasc;
2523         int error_index;
2524         struct ipr_hostrcb_type_21_error *error;
2525
2526         if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2527                 return;
2528
2529         if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2530                 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2531
2532         if (ioa_cfg->sis64)
2533                 ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2534         else
2535                 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2536
2537         if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2538             ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2539                 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2540                 scsi_report_bus_reset(ioa_cfg->host,
2541                                       hostrcb->hcam.u.error.fd_res_addr.bus);
2542         }
2543
2544         error_index = ipr_get_error(ioasc);
2545
2546         if (!ipr_error_table[error_index].log_hcam)
2547                 return;
2548
2549         if (ioasc == IPR_IOASC_HW_CMD_FAILED &&
2550             hostrcb->hcam.overlay_id == IPR_HOST_RCB_OVERLAY_ID_21) {
2551                 error = &hostrcb->hcam.u.error64.u.type_21_error;
2552
2553                 if (((be32_to_cpu(error->sense_data[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST &&
2554                         ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
2555                                 return;
2556         }
2557
2558         ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2559
2560         /* Set indication we have logged an error */
2561         ioa_cfg->errors_logged++;
2562
2563         if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2564                 return;
2565         if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2566                 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2567
2568         switch (hostrcb->hcam.overlay_id) {
2569         case IPR_HOST_RCB_OVERLAY_ID_2:
2570                 ipr_log_cache_error(ioa_cfg, hostrcb);
2571                 break;
2572         case IPR_HOST_RCB_OVERLAY_ID_3:
2573                 ipr_log_config_error(ioa_cfg, hostrcb);
2574                 break;
2575         case IPR_HOST_RCB_OVERLAY_ID_4:
2576         case IPR_HOST_RCB_OVERLAY_ID_6:
2577                 ipr_log_array_error(ioa_cfg, hostrcb);
2578                 break;
2579         case IPR_HOST_RCB_OVERLAY_ID_7:
2580                 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2581                 break;
2582         case IPR_HOST_RCB_OVERLAY_ID_12:
2583                 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2584                 break;
2585         case IPR_HOST_RCB_OVERLAY_ID_13:
2586                 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2587                 break;
2588         case IPR_HOST_RCB_OVERLAY_ID_14:
2589         case IPR_HOST_RCB_OVERLAY_ID_16:
2590                 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2591                 break;
2592         case IPR_HOST_RCB_OVERLAY_ID_17:
2593                 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2594                 break;
2595         case IPR_HOST_RCB_OVERLAY_ID_20:
2596                 ipr_log_fabric_error(ioa_cfg, hostrcb);
2597                 break;
2598         case IPR_HOST_RCB_OVERLAY_ID_21:
2599                 ipr_log_sis64_device_error(ioa_cfg, hostrcb);
2600                 break;
2601         case IPR_HOST_RCB_OVERLAY_ID_23:
2602                 ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2603                 break;
2604         case IPR_HOST_RCB_OVERLAY_ID_24:
2605         case IPR_HOST_RCB_OVERLAY_ID_26:
2606                 ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2607                 break;
2608         case IPR_HOST_RCB_OVERLAY_ID_30:
2609                 ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2610                 break;
2611         case IPR_HOST_RCB_OVERLAY_ID_41:
2612                 ipr_log_sis64_service_required_error(ioa_cfg, hostrcb);
2613                 break;
2614         case IPR_HOST_RCB_OVERLAY_ID_1:
2615         case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2616         default:
2617                 ipr_log_generic_error(ioa_cfg, hostrcb);
2618                 break;
2619         }
2620 }
2621
2622 static struct ipr_hostrcb *ipr_get_free_hostrcb(struct ipr_ioa_cfg *ioa)
2623 {
2624         struct ipr_hostrcb *hostrcb;
2625
2626         hostrcb = list_first_entry_or_null(&ioa->hostrcb_free_q,
2627                                         struct ipr_hostrcb, queue);
2628
2629         if (unlikely(!hostrcb)) {
2630                 dev_info(&ioa->pdev->dev, "Reclaiming async error buffers.");
2631                 hostrcb = list_first_entry_or_null(&ioa->hostrcb_report_q,
2632                                                 struct ipr_hostrcb, queue);
2633         }
2634
2635         list_del_init(&hostrcb->queue);
2636         return hostrcb;
2637 }
2638
2639 /**
2640  * ipr_process_error - Op done function for an adapter error log.
2641  * @ipr_cmd:    ipr command struct
2642  *
2643  * This function is the op done function for an error log host
2644  * controlled async from the adapter. It will log the error and
2645  * send the HCAM back to the adapter.
2646  *
2647  * Return value:
2648  *      none
2649  **/
2650 static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2651 {
2652         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2653         struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2654         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2655         u32 fd_ioasc;
2656
2657         if (ioa_cfg->sis64)
2658                 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2659         else
2660                 fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2661
2662         list_del_init(&hostrcb->queue);
2663         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
2664
2665         if (!ioasc) {
2666                 ipr_handle_log_data(ioa_cfg, hostrcb);
2667                 if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2668                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2669         } else if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
2670                    ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) {
2671                 dev_err(&ioa_cfg->pdev->dev,
2672                         "Host RCB failed with IOASC: 0x%08X\n", ioasc);
2673         }
2674
2675         list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_report_q);
2676         schedule_work(&ioa_cfg->work_q);
2677         hostrcb = ipr_get_free_hostrcb(ioa_cfg);
2678
2679         ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2680 }
2681
2682 /**
2683  * ipr_timeout -  An internally generated op has timed out.
2684  * @ipr_cmd:    ipr command struct
2685  *
2686  * This function blocks host requests and initiates an
2687  * adapter reset.
2688  *
2689  * Return value:
2690  *      none
2691  **/
2692 static void ipr_timeout(struct timer_list *t)
2693 {
2694         struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2695         unsigned long lock_flags = 0;
2696         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2697
2698         ENTER;
2699         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2700
2701         ioa_cfg->errors_logged++;
2702         dev_err(&ioa_cfg->pdev->dev,
2703                 "Adapter being reset due to command timeout.\n");
2704
2705         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2706                 ioa_cfg->sdt_state = GET_DUMP;
2707
2708         if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2709                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2710
2711         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2712         LEAVE;
2713 }
2714
2715 /**
2716  * ipr_oper_timeout -  Adapter timed out transitioning to operational
2717  * @ipr_cmd:    ipr command struct
2718  *
2719  * This function blocks host requests and initiates an
2720  * adapter reset.
2721  *
2722  * Return value:
2723  *      none
2724  **/
2725 static void ipr_oper_timeout(struct timer_list *t)
2726 {
2727         struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
2728         unsigned long lock_flags = 0;
2729         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2730
2731         ENTER;
2732         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2733
2734         ioa_cfg->errors_logged++;
2735         dev_err(&ioa_cfg->pdev->dev,
2736                 "Adapter timed out transitioning to operational.\n");
2737
2738         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2739                 ioa_cfg->sdt_state = GET_DUMP;
2740
2741         if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2742                 if (ipr_fastfail)
2743                         ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2744                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2745         }
2746
2747         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2748         LEAVE;
2749 }
2750
2751 /**
2752  * ipr_find_ses_entry - Find matching SES in SES table
2753  * @res:        resource entry struct of SES
2754  *
2755  * Return value:
2756  *      pointer to SES table entry / NULL on failure
2757  **/
2758 static const struct ipr_ses_table_entry *
2759 ipr_find_ses_entry(struct ipr_resource_entry *res)
2760 {
2761         int i, j, matches;
2762         struct ipr_std_inq_vpids *vpids;
2763         const struct ipr_ses_table_entry *ste = ipr_ses_table;
2764
2765         for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2766                 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2767                         if (ste->compare_product_id_byte[j] == 'X') {
2768                                 vpids = &res->std_inq_data.vpids;
2769                                 if (vpids->product_id[j] == ste->product_id[j])
2770                                         matches++;
2771                                 else
2772                                         break;
2773                         } else
2774                                 matches++;
2775                 }
2776
2777                 if (matches == IPR_PROD_ID_LEN)
2778                         return ste;
2779         }
2780
2781         return NULL;
2782 }
2783
2784 /**
2785  * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2786  * @ioa_cfg:    ioa config struct
2787  * @bus:                SCSI bus
2788  * @bus_width:  bus width
2789  *
2790  * Return value:
2791  *      SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2792  *      For a 2-byte wide SCSI bus, the maximum transfer speed is
2793  *      twice the maximum transfer rate (e.g. for a wide enabled bus,
2794  *      max 160MHz = max 320MB/sec).
2795  **/
2796 static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2797 {
2798         struct ipr_resource_entry *res;
2799         const struct ipr_ses_table_entry *ste;
2800         u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2801
2802         /* Loop through each config table entry in the config table buffer */
2803         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2804                 if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2805                         continue;
2806
2807                 if (bus != res->bus)
2808                         continue;
2809
2810                 if (!(ste = ipr_find_ses_entry(res)))
2811                         continue;
2812
2813                 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2814         }
2815
2816         return max_xfer_rate;
2817 }
2818
2819 /**
2820  * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2821  * @ioa_cfg:            ioa config struct
2822  * @max_delay:          max delay in micro-seconds to wait
2823  *
2824  * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2825  *
2826  * Return value:
2827  *      0 on success / other on failure
2828  **/
2829 static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2830 {
2831         volatile u32 pcii_reg;
2832         int delay = 1;
2833
2834         /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2835         while (delay < max_delay) {
2836                 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2837
2838                 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2839                         return 0;
2840
2841                 /* udelay cannot be used if delay is more than a few milliseconds */
2842                 if ((delay / 1000) > MAX_UDELAY_MS)
2843                         mdelay(delay / 1000);
2844                 else
2845                         udelay(delay);
2846
2847                 delay += delay;
2848         }
2849         return -EIO;
2850 }
2851
2852 /**
2853  * ipr_get_sis64_dump_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
2861  **/
2862 static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2863                                            u32 start_addr,
2864                                            __be32 *dest, u32 length_in_words)
2865 {
2866         int i;
2867
2868         for (i = 0; i < length_in_words; i++) {
2869                 writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2870                 *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2871                 dest++;
2872         }
2873
2874         return 0;
2875 }
2876
2877 /**
2878  * ipr_get_ldump_data_section - Dump IOA memory
2879  * @ioa_cfg:                    ioa config struct
2880  * @start_addr:                 adapter address to dump
2881  * @dest:                               destination kernel buffer
2882  * @length_in_words:    length to dump in 4 byte words
2883  *
2884  * Return value:
2885  *      0 on success / -EIO on failure
2886  **/
2887 static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2888                                       u32 start_addr,
2889                                       __be32 *dest, u32 length_in_words)
2890 {
2891         volatile u32 temp_pcii_reg;
2892         int i, delay = 0;
2893
2894         if (ioa_cfg->sis64)
2895                 return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2896                                                        dest, length_in_words);
2897
2898         /* Write IOA interrupt reg starting LDUMP state  */
2899         writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2900                ioa_cfg->regs.set_uproc_interrupt_reg32);
2901
2902         /* Wait for IO debug acknowledge */
2903         if (ipr_wait_iodbg_ack(ioa_cfg,
2904                                IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2905                 dev_err(&ioa_cfg->pdev->dev,
2906                         "IOA dump long data transfer timeout\n");
2907                 return -EIO;
2908         }
2909
2910         /* Signal LDUMP interlocked - clear IO debug ack */
2911         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2912                ioa_cfg->regs.clr_interrupt_reg);
2913
2914         /* Write Mailbox with starting address */
2915         writel(start_addr, ioa_cfg->ioa_mailbox);
2916
2917         /* Signal address valid - clear IOA Reset alert */
2918         writel(IPR_UPROCI_RESET_ALERT,
2919                ioa_cfg->regs.clr_uproc_interrupt_reg32);
2920
2921         for (i = 0; i < length_in_words; i++) {
2922                 /* Wait for IO debug acknowledge */
2923                 if (ipr_wait_iodbg_ack(ioa_cfg,
2924                                        IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2925                         dev_err(&ioa_cfg->pdev->dev,
2926                                 "IOA dump short data transfer timeout\n");
2927                         return -EIO;
2928                 }
2929
2930                 /* Read data from mailbox and increment destination pointer */
2931                 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2932                 dest++;
2933
2934                 /* For all but the last word of data, signal data received */
2935                 if (i < (length_in_words - 1)) {
2936                         /* Signal dump data received - Clear IO debug Ack */
2937                         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2938                                ioa_cfg->regs.clr_interrupt_reg);
2939                 }
2940         }
2941
2942         /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2943         writel(IPR_UPROCI_RESET_ALERT,
2944                ioa_cfg->regs.set_uproc_interrupt_reg32);
2945
2946         writel(IPR_UPROCI_IO_DEBUG_ALERT,
2947                ioa_cfg->regs.clr_uproc_interrupt_reg32);
2948
2949         /* Signal dump data received - Clear IO debug Ack */
2950         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2951                ioa_cfg->regs.clr_interrupt_reg);
2952
2953         /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2954         while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2955                 temp_pcii_reg =
2956                     readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2957
2958                 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2959                         return 0;
2960
2961                 udelay(10);
2962                 delay += 10;
2963         }
2964
2965         return 0;
2966 }
2967
2968 #ifdef CONFIG_SCSI_IPR_DUMP
2969 /**
2970  * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2971  * @ioa_cfg:            ioa config struct
2972  * @pci_address:        adapter address
2973  * @length:                     length of data to copy
2974  *
2975  * Copy data from PCI adapter to kernel buffer.
2976  * Note: length MUST be a 4 byte multiple
2977  * Return value:
2978  *      0 on success / other on failure
2979  **/
2980 static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2981                         unsigned long pci_address, u32 length)
2982 {
2983         int bytes_copied = 0;
2984         int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2985         __be32 *page;
2986         unsigned long lock_flags = 0;
2987         struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2988
2989         if (ioa_cfg->sis64)
2990                 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2991         else
2992                 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2993
2994         while (bytes_copied < length &&
2995                (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2996                 if (ioa_dump->page_offset >= PAGE_SIZE ||
2997                     ioa_dump->page_offset == 0) {
2998                         page = (__be32 *)__get_free_page(GFP_ATOMIC);
2999
3000                         if (!page) {
3001                                 ipr_trace;
3002                                 return bytes_copied;
3003                         }
3004
3005                         ioa_dump->page_offset = 0;
3006                         ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
3007                         ioa_dump->next_page_index++;
3008                 } else
3009                         page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
3010
3011                 rem_len = length - bytes_copied;
3012                 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
3013                 cur_len = min(rem_len, rem_page_len);
3014
3015                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3016                 if (ioa_cfg->sdt_state == ABORT_DUMP) {
3017                         rc = -EIO;
3018                 } else {
3019                         rc = ipr_get_ldump_data_section(ioa_cfg,
3020                                                         pci_address + bytes_copied,
3021                                                         &page[ioa_dump->page_offset / 4],
3022                                                         (cur_len / sizeof(u32)));
3023                 }
3024                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3025
3026                 if (!rc) {
3027                         ioa_dump->page_offset += cur_len;
3028                         bytes_copied += cur_len;
3029                 } else {
3030                         ipr_trace;
3031                         break;
3032                 }
3033                 schedule();
3034         }
3035
3036         return bytes_copied;
3037 }
3038
3039 /**
3040  * ipr_init_dump_entry_hdr - Initialize a dump entry header.
3041  * @hdr:        dump entry header struct
3042  *
3043  * Return value:
3044  *      nothing
3045  **/
3046 static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
3047 {
3048         hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
3049         hdr->num_elems = 1;
3050         hdr->offset = sizeof(*hdr);
3051         hdr->status = IPR_DUMP_STATUS_SUCCESS;
3052 }
3053
3054 /**
3055  * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
3056  * @ioa_cfg:    ioa config struct
3057  * @driver_dump:        driver dump struct
3058  *
3059  * Return value:
3060  *      nothing
3061  **/
3062 static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
3063                                    struct ipr_driver_dump *driver_dump)
3064 {
3065         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3066
3067         ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
3068         driver_dump->ioa_type_entry.hdr.len =
3069                 sizeof(struct ipr_dump_ioa_type_entry) -
3070                 sizeof(struct ipr_dump_entry_header);
3071         driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3072         driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
3073         driver_dump->ioa_type_entry.type = ioa_cfg->type;
3074         driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
3075                 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
3076                 ucode_vpd->minor_release[1];
3077         driver_dump->hdr.num_entries++;
3078 }
3079
3080 /**
3081  * ipr_dump_version_data - Fill in the driver version in the dump.
3082  * @ioa_cfg:    ioa config struct
3083  * @driver_dump:        driver dump struct
3084  *
3085  * Return value:
3086  *      nothing
3087  **/
3088 static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
3089                                   struct ipr_driver_dump *driver_dump)
3090 {
3091         ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
3092         driver_dump->version_entry.hdr.len =
3093                 sizeof(struct ipr_dump_version_entry) -
3094                 sizeof(struct ipr_dump_entry_header);
3095         driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3096         driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
3097         strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
3098         driver_dump->hdr.num_entries++;
3099 }
3100
3101 /**
3102  * ipr_dump_trace_data - Fill in the IOA trace in the dump.
3103  * @ioa_cfg:    ioa config struct
3104  * @driver_dump:        driver dump struct
3105  *
3106  * Return value:
3107  *      nothing
3108  **/
3109 static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
3110                                    struct ipr_driver_dump *driver_dump)
3111 {
3112         ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
3113         driver_dump->trace_entry.hdr.len =
3114                 sizeof(struct ipr_dump_trace_entry) -
3115                 sizeof(struct ipr_dump_entry_header);
3116         driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3117         driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
3118         memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
3119         driver_dump->hdr.num_entries++;
3120 }
3121
3122 /**
3123  * ipr_dump_location_data - Fill in the IOA location in the dump.
3124  * @ioa_cfg:    ioa config struct
3125  * @driver_dump:        driver dump struct
3126  *
3127  * Return value:
3128  *      nothing
3129  **/
3130 static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
3131                                    struct ipr_driver_dump *driver_dump)
3132 {
3133         ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
3134         driver_dump->location_entry.hdr.len =
3135                 sizeof(struct ipr_dump_location_entry) -
3136                 sizeof(struct ipr_dump_entry_header);
3137         driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
3138         driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
3139         strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
3140         driver_dump->hdr.num_entries++;
3141 }
3142
3143 /**
3144  * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
3145  * @ioa_cfg:    ioa config struct
3146  * @dump:               dump struct
3147  *
3148  * Return value:
3149  *      nothing
3150  **/
3151 static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
3152 {
3153         unsigned long start_addr, sdt_word;
3154         unsigned long lock_flags = 0;
3155         struct ipr_driver_dump *driver_dump = &dump->driver_dump;
3156         struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
3157         u32 num_entries, max_num_entries, start_off, end_off;
3158         u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
3159         struct ipr_sdt *sdt;
3160         int valid = 1;
3161         int i;
3162
3163         ENTER;
3164
3165         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3166
3167         if (ioa_cfg->sdt_state != READ_DUMP) {
3168                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3169                 return;
3170         }
3171
3172         if (ioa_cfg->sis64) {
3173                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3174                 ssleep(IPR_DUMP_DELAY_SECONDS);
3175                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3176         }
3177
3178         start_addr = readl(ioa_cfg->ioa_mailbox);
3179
3180         if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
3181                 dev_err(&ioa_cfg->pdev->dev,
3182                         "Invalid dump table format: %lx\n", start_addr);
3183                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3184                 return;
3185         }
3186
3187         dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
3188
3189         driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
3190
3191         /* Initialize the overall dump header */
3192         driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
3193         driver_dump->hdr.num_entries = 1;
3194         driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
3195         driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
3196         driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
3197         driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
3198
3199         ipr_dump_version_data(ioa_cfg, driver_dump);
3200         ipr_dump_location_data(ioa_cfg, driver_dump);
3201         ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
3202         ipr_dump_trace_data(ioa_cfg, driver_dump);
3203
3204         /* Update dump_header */
3205         driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
3206
3207         /* IOA Dump entry */
3208         ipr_init_dump_entry_hdr(&ioa_dump->hdr);
3209         ioa_dump->hdr.len = 0;
3210         ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3211         ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
3212
3213         /* First entries in sdt are actually a list of dump addresses and
3214          lengths to gather the real dump data.  sdt represents the pointer
3215          to the ioa generated dump table.  Dump data will be extracted based
3216          on entries in this table */
3217         sdt = &ioa_dump->sdt;
3218
3219         if (ioa_cfg->sis64) {
3220                 max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
3221                 max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
3222         } else {
3223                 max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
3224                 max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
3225         }
3226
3227         bytes_to_copy = offsetof(struct ipr_sdt, entry) +
3228                         (max_num_entries * sizeof(struct ipr_sdt_entry));
3229         rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
3230                                         bytes_to_copy / sizeof(__be32));
3231
3232         /* Smart Dump table is ready to use and the first entry is valid */
3233         if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
3234             (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
3235                 dev_err(&ioa_cfg->pdev->dev,
3236                         "Dump of IOA failed. Dump table not valid: %d, %X.\n",
3237                         rc, be32_to_cpu(sdt->hdr.state));
3238                 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
3239                 ioa_cfg->sdt_state = DUMP_OBTAINED;
3240                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3241                 return;
3242         }
3243
3244         num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
3245
3246         if (num_entries > max_num_entries)
3247                 num_entries = max_num_entries;
3248
3249         /* Update dump length to the actual data to be copied */
3250         dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
3251         if (ioa_cfg->sis64)
3252                 dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
3253         else
3254                 dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
3255
3256         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3257
3258         for (i = 0; i < num_entries; i++) {
3259                 if (ioa_dump->hdr.len > max_dump_size) {
3260                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3261                         break;
3262                 }
3263
3264                 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3265                         sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3266                         if (ioa_cfg->sis64)
3267                                 bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3268                         else {
3269                                 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3270                                 end_off = be32_to_cpu(sdt->entry[i].end_token);
3271
3272                                 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3273                                         bytes_to_copy = end_off - start_off;
3274                                 else
3275                                         valid = 0;
3276                         }
3277                         if (valid) {
3278                                 if (bytes_to_copy > max_dump_size) {
3279                                         sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3280                                         continue;
3281                                 }
3282
3283                                 /* Copy data from adapter to driver buffers */
3284                                 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3285                                                             bytes_to_copy);
3286
3287                                 ioa_dump->hdr.len += bytes_copied;
3288
3289                                 if (bytes_copied != bytes_to_copy) {
3290                                         driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3291                                         break;
3292                                 }
3293                         }
3294                 }
3295         }
3296
3297         dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3298
3299         /* Update dump_header */
3300         driver_dump->hdr.len += ioa_dump->hdr.len;
3301         wmb();
3302         ioa_cfg->sdt_state = DUMP_OBTAINED;
3303         LEAVE;
3304 }
3305
3306 #else
3307 #define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3308 #endif
3309
3310 /**
3311  * ipr_release_dump - Free adapter dump memory
3312  * @kref:       kref struct
3313  *
3314  * Return value:
3315  *      nothing
3316  **/
3317 static void ipr_release_dump(struct kref *kref)
3318 {
3319         struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3320         struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3321         unsigned long lock_flags = 0;
3322         int i;
3323
3324         ENTER;
3325         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3326         ioa_cfg->dump = NULL;
3327         ioa_cfg->sdt_state = INACTIVE;
3328         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3329
3330         for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3331                 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3332
3333         vfree(dump->ioa_dump.ioa_data);
3334         kfree(dump);
3335         LEAVE;
3336 }
3337
3338 static void ipr_add_remove_thread(struct work_struct *work)
3339 {
3340         unsigned long lock_flags;
3341         struct ipr_resource_entry *res;
3342         struct scsi_device *sdev;
3343         struct ipr_ioa_cfg *ioa_cfg =
3344                 container_of(work, struct ipr_ioa_cfg, scsi_add_work_q);
3345         u8 bus, target, lun;
3346         int did_work;
3347
3348         ENTER;
3349         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3350
3351 restart:
3352         do {
3353                 did_work = 0;
3354                 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
3355                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3356                         return;
3357                 }
3358
3359                 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3360                         if (res->del_from_ml && res->sdev) {
3361                                 did_work = 1;
3362                                 sdev = res->sdev;
3363                                 if (!scsi_device_get(sdev)) {
3364                                         if (!res->add_to_ml)
3365                                                 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3366                                         else
3367                                                 res->del_from_ml = 0;
3368                                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3369                                         scsi_remove_device(sdev);
3370                                         scsi_device_put(sdev);
3371                                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3372                                 }
3373                                 break;
3374                         }
3375                 }
3376         } while (did_work);
3377
3378         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3379                 if (res->add_to_ml) {
3380                         bus = res->bus;
3381                         target = res->target;
3382                         lun = res->lun;
3383                         res->add_to_ml = 0;
3384                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3385                         scsi_add_device(ioa_cfg->host, bus, target, lun);
3386                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3387                         goto restart;
3388                 }
3389         }
3390
3391         ioa_cfg->scan_done = 1;
3392         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3393         kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3394         LEAVE;
3395 }
3396
3397 /**
3398  * ipr_worker_thread - Worker thread
3399  * @work:               ioa config struct
3400  *
3401  * Called at task level from a work thread. This function takes care
3402  * of adding and removing device from the mid-layer as configuration
3403  * changes are detected by the adapter.
3404  *
3405  * Return value:
3406  *      nothing
3407  **/
3408 static void ipr_worker_thread(struct work_struct *work)
3409 {
3410         unsigned long lock_flags;
3411         struct ipr_dump *dump;
3412         struct ipr_ioa_cfg *ioa_cfg =
3413                 container_of(work, struct ipr_ioa_cfg, work_q);
3414
3415         ENTER;
3416         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3417
3418         if (ioa_cfg->sdt_state == READ_DUMP) {
3419                 dump = ioa_cfg->dump;
3420                 if (!dump) {
3421                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3422                         return;
3423                 }
3424                 kref_get(&dump->kref);
3425                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3426                 ipr_get_ioa_dump(ioa_cfg, dump);
3427                 kref_put(&dump->kref, ipr_release_dump);
3428
3429                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3430                 if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3431                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3432                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3433                 return;
3434         }
3435
3436         if (ioa_cfg->scsi_unblock) {
3437                 ioa_cfg->scsi_unblock = 0;
3438                 ioa_cfg->scsi_blocked = 0;
3439                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3440                 scsi_unblock_requests(ioa_cfg->host);
3441                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3442                 if (ioa_cfg->scsi_blocked)
3443                         scsi_block_requests(ioa_cfg->host);
3444         }
3445
3446         if (!ioa_cfg->scan_enabled) {
3447                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3448                 return;
3449         }
3450
3451         schedule_work(&ioa_cfg->scsi_add_work_q);
3452
3453         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3454         LEAVE;
3455 }
3456
3457 #ifdef CONFIG_SCSI_IPR_TRACE
3458 /**
3459  * ipr_read_trace - Dump the adapter trace
3460  * @filp:               open sysfs file
3461  * @kobj:               kobject struct
3462  * @bin_attr:           bin_attribute struct
3463  * @buf:                buffer
3464  * @off:                offset
3465  * @count:              buffer size
3466  *
3467  * Return value:
3468  *      number of bytes printed to buffer
3469  **/
3470 static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3471                               struct bin_attribute *bin_attr,
3472                               char *buf, loff_t off, size_t count)
3473 {
3474         struct device *dev = container_of(kobj, struct device, kobj);
3475         struct Scsi_Host *shost = class_to_shost(dev);
3476         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3477         unsigned long lock_flags = 0;
3478         ssize_t ret;
3479
3480         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3481         ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3482                                 IPR_TRACE_SIZE);
3483         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3484
3485         return ret;
3486 }
3487
3488 static struct bin_attribute ipr_trace_attr = {
3489         .attr = {
3490                 .name = "trace",
3491                 .mode = S_IRUGO,
3492         },
3493         .size = 0,
3494         .read = ipr_read_trace,
3495 };
3496 #endif
3497
3498 /**
3499  * ipr_show_fw_version - Show the firmware version
3500  * @dev:        class device struct
3501  * @buf:        buffer
3502  *
3503  * Return value:
3504  *      number of bytes printed to buffer
3505  **/
3506 static ssize_t ipr_show_fw_version(struct device *dev,
3507                                    struct device_attribute *attr, char *buf)
3508 {
3509         struct Scsi_Host *shost = class_to_shost(dev);
3510         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3511         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3512         unsigned long lock_flags = 0;
3513         int len;
3514
3515         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3516         len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3517                        ucode_vpd->major_release, ucode_vpd->card_type,
3518                        ucode_vpd->minor_release[0],
3519                        ucode_vpd->minor_release[1]);
3520         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3521         return len;
3522 }
3523
3524 static struct device_attribute ipr_fw_version_attr = {
3525         .attr = {
3526                 .name =         "fw_version",
3527                 .mode =         S_IRUGO,
3528         },
3529         .show = ipr_show_fw_version,
3530 };
3531
3532 /**
3533  * ipr_show_log_level - Show the adapter's error logging level
3534  * @dev:        class device struct
3535  * @buf:        buffer
3536  *
3537  * Return value:
3538  *      number of bytes printed to buffer
3539  **/
3540 static ssize_t ipr_show_log_level(struct device *dev,
3541                                    struct device_attribute *attr, char *buf)
3542 {
3543         struct Scsi_Host *shost = class_to_shost(dev);
3544         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3545         unsigned long lock_flags = 0;
3546         int len;
3547
3548         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3549         len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3550         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3551         return len;
3552 }
3553
3554 /**
3555  * ipr_store_log_level - Change the adapter's error logging level
3556  * @dev:        class device struct
3557  * @buf:        buffer
3558  *
3559  * Return value:
3560  *      number of bytes printed to buffer
3561  **/
3562 static ssize_t ipr_store_log_level(struct device *dev,
3563                                    struct device_attribute *attr,
3564                                    const char *buf, size_t count)
3565 {
3566         struct Scsi_Host *shost = class_to_shost(dev);
3567         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3568         unsigned long lock_flags = 0;
3569
3570         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3571         ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3572         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3573         return strlen(buf);
3574 }
3575
3576 static struct device_attribute ipr_log_level_attr = {
3577         .attr = {
3578                 .name =         "log_level",
3579                 .mode =         S_IRUGO | S_IWUSR,
3580         },
3581         .show = ipr_show_log_level,
3582         .store = ipr_store_log_level
3583 };
3584
3585 /**
3586  * ipr_store_diagnostics - IOA Diagnostics interface
3587  * @dev:        device struct
3588  * @buf:        buffer
3589  * @count:      buffer size
3590  *
3591  * This function will reset the adapter and wait a reasonable
3592  * amount of time for any errors that the adapter might log.
3593  *
3594  * Return value:
3595  *      count on success / other on failure
3596  **/
3597 static ssize_t ipr_store_diagnostics(struct device *dev,
3598                                      struct device_attribute *attr,
3599                                      const char *buf, size_t count)
3600 {
3601         struct Scsi_Host *shost = class_to_shost(dev);
3602         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3603         unsigned long lock_flags = 0;
3604         int rc = count;
3605
3606         if (!capable(CAP_SYS_ADMIN))
3607                 return -EACCES;
3608
3609         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3610         while (ioa_cfg->in_reset_reload) {
3611                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3612                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3613                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3614         }
3615
3616         ioa_cfg->errors_logged = 0;
3617         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3618
3619         if (ioa_cfg->in_reset_reload) {
3620                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3621                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3622
3623                 /* Wait for a second for any errors to be logged */
3624                 msleep(1000);
3625         } else {
3626                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3627                 return -EIO;
3628         }
3629
3630         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3631         if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3632                 rc = -EIO;
3633         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3634
3635         return rc;
3636 }
3637
3638 static struct device_attribute ipr_diagnostics_attr = {
3639         .attr = {
3640                 .name =         "run_diagnostics",
3641                 .mode =         S_IWUSR,
3642         },
3643         .store = ipr_store_diagnostics
3644 };
3645
3646 /**
3647  * ipr_show_adapter_state - Show the adapter's state
3648  * @class_dev:  device struct
3649  * @buf:        buffer
3650  *
3651  * Return value:
3652  *      number of bytes printed to buffer
3653  **/
3654 static ssize_t ipr_show_adapter_state(struct device *dev,
3655                                       struct device_attribute *attr, char *buf)
3656 {
3657         struct Scsi_Host *shost = class_to_shost(dev);
3658         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3659         unsigned long lock_flags = 0;
3660         int len;
3661
3662         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3663         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
3664                 len = snprintf(buf, PAGE_SIZE, "offline\n");
3665         else
3666                 len = snprintf(buf, PAGE_SIZE, "online\n");
3667         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3668         return len;
3669 }
3670
3671 /**
3672  * ipr_store_adapter_state - Change adapter state
3673  * @dev:        device struct
3674  * @buf:        buffer
3675  * @count:      buffer size
3676  *
3677  * This function will change the adapter's state.
3678  *
3679  * Return value:
3680  *      count on success / other on failure
3681  **/
3682 static ssize_t ipr_store_adapter_state(struct device *dev,
3683                                        struct device_attribute *attr,
3684                                        const char *buf, size_t count)
3685 {
3686         struct Scsi_Host *shost = class_to_shost(dev);
3687         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3688         unsigned long lock_flags;
3689         int result = count, i;
3690
3691         if (!capable(CAP_SYS_ADMIN))
3692                 return -EACCES;
3693
3694         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3695         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead &&
3696             !strncmp(buf, "online", 6)) {
3697                 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
3698                         spin_lock(&ioa_cfg->hrrq[i]._lock);
3699                         ioa_cfg->hrrq[i].ioa_is_dead = 0;
3700                         spin_unlock(&ioa_cfg->hrrq[i]._lock);
3701                 }
3702                 wmb();
3703                 ioa_cfg->reset_retries = 0;
3704                 ioa_cfg->in_ioa_bringdown = 0;
3705                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3706         }
3707         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3708         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3709
3710         return result;
3711 }
3712
3713 static struct device_attribute ipr_ioa_state_attr = {
3714         .attr = {
3715                 .name =         "online_state",
3716                 .mode =         S_IRUGO | S_IWUSR,
3717         },
3718         .show = ipr_show_adapter_state,
3719         .store = ipr_store_adapter_state
3720 };
3721
3722 /**
3723  * ipr_store_reset_adapter - Reset the adapter
3724  * @dev:        device struct
3725  * @buf:        buffer
3726  * @count:      buffer size
3727  *
3728  * This function will reset the adapter.
3729  *
3730  * Return value:
3731  *      count on success / other on failure
3732  **/
3733 static ssize_t ipr_store_reset_adapter(struct device *dev,
3734                                        struct device_attribute *attr,
3735                                        const char *buf, size_t count)
3736 {
3737         struct Scsi_Host *shost = class_to_shost(dev);
3738         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3739         unsigned long lock_flags;
3740         int result = count;
3741
3742         if (!capable(CAP_SYS_ADMIN))
3743                 return -EACCES;
3744
3745         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3746         if (!ioa_cfg->in_reset_reload)
3747                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3748         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3749         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3750
3751         return result;
3752 }
3753
3754 static struct device_attribute ipr_ioa_reset_attr = {
3755         .attr = {
3756                 .name =         "reset_host",
3757                 .mode =         S_IWUSR,
3758         },
3759         .store = ipr_store_reset_adapter
3760 };
3761
3762 static int ipr_iopoll(struct irq_poll *iop, int budget);
3763  /**
3764  * ipr_show_iopoll_weight - Show ipr polling mode
3765  * @dev:        class device struct
3766  * @buf:        buffer
3767  *
3768  * Return value:
3769  *      number of bytes printed to buffer
3770  **/
3771 static ssize_t ipr_show_iopoll_weight(struct device *dev,
3772                                    struct device_attribute *attr, char *buf)
3773 {
3774         struct Scsi_Host *shost = class_to_shost(dev);
3775         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3776         unsigned long lock_flags = 0;
3777         int len;
3778
3779         spin_lock_irqsave(shost->host_lock, lock_flags);
3780         len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight);
3781         spin_unlock_irqrestore(shost->host_lock, lock_flags);
3782
3783         return len;
3784 }
3785
3786 /**
3787  * ipr_store_iopoll_weight - Change the adapter's polling mode
3788  * @dev:        class device struct
3789  * @buf:        buffer
3790  *
3791  * Return value:
3792  *      number of bytes printed to buffer
3793  **/
3794 static ssize_t ipr_store_iopoll_weight(struct device *dev,
3795                                         struct device_attribute *attr,
3796                                         const char *buf, size_t count)
3797 {
3798         struct Scsi_Host *shost = class_to_shost(dev);
3799         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3800         unsigned long user_iopoll_weight;
3801         unsigned long lock_flags = 0;
3802         int i;
3803
3804         if (!ioa_cfg->sis64) {
3805                 dev_info(&ioa_cfg->pdev->dev, "irq_poll not supported on this adapter\n");
3806                 return -EINVAL;
3807         }
3808         if (kstrtoul(buf, 10, &user_iopoll_weight))
3809                 return -EINVAL;
3810
3811         if (user_iopoll_weight > 256) {
3812                 dev_info(&ioa_cfg->pdev->dev, "Invalid irq_poll weight. It must be less than 256\n");
3813                 return -EINVAL;
3814         }
3815
3816         if (user_iopoll_weight == ioa_cfg->iopoll_weight) {
3817                 dev_info(&ioa_cfg->pdev->dev, "Current irq_poll weight has the same weight\n");
3818                 return strlen(buf);
3819         }
3820
3821         if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3822                 for (i = 1; i < ioa_cfg->hrrq_num; i++)
3823                         irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
3824         }
3825
3826         spin_lock_irqsave(shost->host_lock, lock_flags);
3827         ioa_cfg->iopoll_weight = user_iopoll_weight;
3828         if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3829                 for (i = 1; i < ioa_cfg->hrrq_num; i++) {
3830                         irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
3831                                         ioa_cfg->iopoll_weight, ipr_iopoll);
3832                 }
3833         }
3834         spin_unlock_irqrestore(shost->host_lock, lock_flags);
3835
3836         return strlen(buf);
3837 }
3838
3839 static struct device_attribute ipr_iopoll_weight_attr = {
3840         .attr = {
3841                 .name =         "iopoll_weight",
3842                 .mode =         S_IRUGO | S_IWUSR,
3843         },
3844         .show = ipr_show_iopoll_weight,
3845         .store = ipr_store_iopoll_weight
3846 };
3847
3848 /**
3849  * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3850  * @buf_len:            buffer length
3851  *
3852  * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3853  * list to use for microcode download
3854  *
3855  * Return value:
3856  *      pointer to sglist / NULL on failure
3857  **/
3858 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3859 {
3860         int sg_size, order;
3861         struct ipr_sglist *sglist;
3862
3863         /* Get the minimum size per scatter/gather element */
3864         sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3865
3866         /* Get the actual size per element */
3867         order = get_order(sg_size);
3868
3869         /* Allocate a scatter/gather list for the DMA */
3870         sglist = kzalloc(sizeof(struct ipr_sglist), GFP_KERNEL);
3871         if (sglist == NULL) {
3872                 ipr_trace;
3873                 return NULL;
3874         }
3875         sglist->order = order;
3876         sglist->scatterlist = sgl_alloc_order(buf_len, order, false, GFP_KERNEL,
3877                                               &sglist->num_sg);
3878         if (!sglist->scatterlist) {
3879                 kfree(sglist);
3880                 return NULL;
3881         }
3882
3883         return sglist;
3884 }
3885
3886 /**
3887  * ipr_free_ucode_buffer - Frees a microcode download buffer
3888  * @p_dnld:             scatter/gather list pointer
3889  *
3890  * Free a DMA'able ucode download buffer previously allocated with
3891  * ipr_alloc_ucode_buffer
3892  *
3893  * Return value:
3894  *      nothing
3895  **/
3896 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3897 {
3898         sgl_free_order(sglist->scatterlist, sglist->order);
3899         kfree(sglist);
3900 }
3901
3902 /**
3903  * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3904  * @sglist:             scatter/gather list pointer
3905  * @buffer:             buffer pointer
3906  * @len:                buffer length
3907  *
3908  * Copy a microcode image from a user buffer into a buffer allocated by
3909  * ipr_alloc_ucode_buffer
3910  *
3911  * Return value:
3912  *      0 on success / other on failure
3913  **/
3914 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3915                                  u8 *buffer, u32 len)
3916 {
3917         int bsize_elem, i, result = 0;
3918         struct scatterlist *scatterlist;
3919         void *kaddr;
3920
3921         /* Determine the actual number of bytes per element */
3922         bsize_elem = PAGE_SIZE * (1 << sglist->order);
3923
3924         scatterlist = sglist->scatterlist;
3925
3926         for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3927                 struct page *page = sg_page(&scatterlist[i]);
3928
3929                 kaddr = kmap(page);
3930                 memcpy(kaddr, buffer, bsize_elem);
3931                 kunmap(page);
3932
3933                 scatterlist[i].length = bsize_elem;
3934
3935                 if (result != 0) {
3936                         ipr_trace;
3937                         return result;
3938                 }
3939         }
3940
3941         if (len % bsize_elem) {
3942                 struct page *page = sg_page(&scatterlist[i]);
3943
3944                 kaddr = kmap(page);
3945                 memcpy(kaddr, buffer, len % bsize_elem);
3946                 kunmap(page);
3947
3948                 scatterlist[i].length = len % bsize_elem;
3949         }
3950
3951         sglist->buffer_len = len;
3952         return result;
3953 }
3954
3955 /**
3956  * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3957  * @ipr_cmd:            ipr command struct
3958  * @sglist:             scatter/gather list
3959  *
3960  * Builds a microcode download IOA data list (IOADL).
3961  *
3962  **/
3963 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3964                                     struct ipr_sglist *sglist)
3965 {
3966         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3967         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3968         struct scatterlist *scatterlist = sglist->scatterlist;
3969         int i;
3970
3971         ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3972         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3973         ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3974
3975         ioarcb->ioadl_len =
3976                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3977         for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3978                 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3979                 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
3980                 ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
3981         }
3982
3983         ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3984 }
3985
3986 /**
3987  * ipr_build_ucode_ioadl - Build a microcode download IOADL
3988  * @ipr_cmd:    ipr command struct
3989  * @sglist:             scatter/gather list
3990  *
3991  * Builds a microcode download IOA data list (IOADL).
3992  *
3993  **/
3994 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3995                                   struct ipr_sglist *sglist)
3996 {
3997         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3998         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3999         struct scatterlist *scatterlist = sglist->scatterlist;
4000         int i;
4001
4002         ipr_cmd->dma_use_sg = sglist->num_dma_sg;
4003         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4004         ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
4005
4006         ioarcb->ioadl_len =
4007                 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
4008
4009         for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
4010                 ioadl[i].flags_and_data_len =
4011                         cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
4012                 ioadl[i].address =
4013                         cpu_to_be32(sg_dma_address(&scatterlist[i]));
4014         }
4015
4016         ioadl[i-1].flags_and_data_len |=
4017                 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
4018 }
4019
4020 /**
4021  * ipr_update_ioa_ucode - Update IOA's microcode
4022  * @ioa_cfg:    ioa config struct
4023  * @sglist:             scatter/gather list
4024  *
4025  * Initiate an adapter reset to update the IOA's microcode
4026  *
4027  * Return value:
4028  *      0 on success / -EIO on failure
4029  **/
4030 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
4031                                 struct ipr_sglist *sglist)
4032 {
4033         unsigned long lock_flags;
4034
4035         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4036         while (ioa_cfg->in_reset_reload) {
4037                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4038                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4039                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4040         }
4041
4042         if (ioa_cfg->ucode_sglist) {
4043                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4044                 dev_err(&ioa_cfg->pdev->dev,
4045                         "Microcode download already in progress\n");
4046                 return -EIO;
4047         }
4048
4049         sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
4050                                         sglist->scatterlist, sglist->num_sg,
4051                                         DMA_TO_DEVICE);
4052
4053         if (!sglist->num_dma_sg) {
4054                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4055                 dev_err(&ioa_cfg->pdev->dev,
4056                         "Failed to map microcode download buffer!\n");
4057                 return -EIO;
4058         }
4059
4060         ioa_cfg->ucode_sglist = sglist;
4061         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
4062         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4063         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4064
4065         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4066         ioa_cfg->ucode_sglist = NULL;
4067         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4068         return 0;
4069 }
4070
4071 /**
4072  * ipr_store_update_fw - Update the firmware on the adapter
4073  * @class_dev:  device struct
4074  * @buf:        buffer
4075  * @count:      buffer size
4076  *
4077  * This function will update the firmware on the adapter.
4078  *
4079  * Return value:
4080  *      count on success / other on failure
4081  **/
4082 static ssize_t ipr_store_update_fw(struct device *dev,
4083                                    struct device_attribute *attr,
4084                                    const char *buf, size_t count)
4085 {
4086         struct Scsi_Host *shost = class_to_shost(dev);
4087         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4088         struct ipr_ucode_image_header *image_hdr;
4089         const struct firmware *fw_entry;
4090         struct ipr_sglist *sglist;
4091         char fname[100];
4092         char *src;
4093         char *endline;
4094         int result, dnld_size;
4095
4096         if (!capable(CAP_SYS_ADMIN))
4097                 return -EACCES;
4098
4099         snprintf(fname, sizeof(fname), "%s", buf);
4100
4101         endline = strchr(fname, '\n');
4102         if (endline)
4103                 *endline = '\0';
4104
4105         if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
4106                 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
4107                 return -EIO;
4108         }
4109
4110         image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
4111
4112         src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
4113         dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
4114         sglist = ipr_alloc_ucode_buffer(dnld_size);
4115
4116         if (!sglist) {
4117                 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
4118                 release_firmware(fw_entry);
4119                 return -ENOMEM;
4120         }
4121
4122         result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
4123
4124         if (result) {
4125                 dev_err(&ioa_cfg->pdev->dev,
4126                         "Microcode buffer copy to DMA buffer failed\n");
4127                 goto out;
4128         }
4129
4130         ipr_info("Updating microcode, please be patient.  This may take up to 30 minutes.\n");
4131
4132         result = ipr_update_ioa_ucode(ioa_cfg, sglist);
4133
4134         if (!result)
4135                 result = count;
4136 out:
4137         ipr_free_ucode_buffer(sglist);
4138         release_firmware(fw_entry);
4139         return result;
4140 }
4141
4142 static struct device_attribute ipr_update_fw_attr = {
4143         .attr = {
4144                 .name =         "update_fw",
4145                 .mode =         S_IWUSR,
4146         },
4147         .store = ipr_store_update_fw
4148 };
4149
4150 /**
4151  * ipr_show_fw_type - Show the adapter's firmware type.
4152  * @dev:        class device struct
4153  * @buf:        buffer
4154  *
4155  * Return value:
4156  *      number of bytes printed to buffer
4157  **/
4158 static ssize_t ipr_show_fw_type(struct device *dev,
4159                                 struct device_attribute *attr, char *buf)
4160 {
4161         struct Scsi_Host *shost = class_to_shost(dev);
4162         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4163         unsigned long lock_flags = 0;
4164         int len;
4165
4166         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4167         len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
4168         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4169         return len;
4170 }
4171
4172 static struct device_attribute ipr_ioa_fw_type_attr = {
4173         .attr = {
4174                 .name =         "fw_type",
4175                 .mode =         S_IRUGO,
4176         },
4177         .show = ipr_show_fw_type
4178 };
4179
4180 static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj,
4181                                 struct bin_attribute *bin_attr, char *buf,
4182                                 loff_t off, size_t count)
4183 {
4184         struct device *cdev = container_of(kobj, struct device, kobj);
4185         struct Scsi_Host *shost = class_to_shost(cdev);
4186         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4187         struct ipr_hostrcb *hostrcb;
4188         unsigned long lock_flags = 0;
4189         int ret;
4190
4191         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4192         hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4193                                         struct ipr_hostrcb, queue);
4194         if (!hostrcb) {
4195                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4196                 return 0;
4197         }
4198         ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam,
4199                                 sizeof(hostrcb->hcam));
4200         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4201         return ret;
4202 }
4203
4204 static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj,
4205                                 struct bin_attribute *bin_attr, char *buf,
4206                                 loff_t off, size_t count)
4207 {
4208         struct device *cdev = container_of(kobj, struct device, kobj);
4209         struct Scsi_Host *shost = class_to_shost(cdev);
4210         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4211         struct ipr_hostrcb *hostrcb;
4212         unsigned long lock_flags = 0;
4213
4214         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4215         hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
4216                                         struct ipr_hostrcb, queue);
4217         if (!hostrcb) {
4218                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4219                 return count;
4220         }
4221
4222         /* Reclaim hostrcb before exit */
4223         list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
4224         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4225         return count;
4226 }
4227
4228 static struct bin_attribute ipr_ioa_async_err_log = {
4229         .attr = {
4230                 .name =         "async_err_log",
4231                 .mode =         S_IRUGO | S_IWUSR,
4232         },
4233         .size = 0,
4234         .read = ipr_read_async_err_log,
4235         .write = ipr_next_async_err_log
4236 };
4237
4238 static struct device_attribute *ipr_ioa_attrs[] = {
4239         &ipr_fw_version_attr,
4240         &ipr_log_level_attr,
4241         &ipr_diagnostics_attr,
4242         &ipr_ioa_state_attr,
4243         &ipr_ioa_reset_attr,
4244         &ipr_update_fw_attr,
4245         &ipr_ioa_fw_type_attr,
4246         &ipr_iopoll_weight_attr,
4247         NULL,
4248 };
4249
4250 #ifdef CONFIG_SCSI_IPR_DUMP
4251 /**
4252  * ipr_read_dump - Dump the adapter
4253  * @filp:               open sysfs file
4254  * @kobj:               kobject struct
4255  * @bin_attr:           bin_attribute struct
4256  * @buf:                buffer
4257  * @off:                offset
4258  * @count:              buffer size
4259  *
4260  * Return value:
4261  *      number of bytes printed to buffer
4262  **/
4263 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
4264                              struct bin_attribute *bin_attr,
4265                              char *buf, loff_t off, size_t count)
4266 {
4267         struct device *cdev = container_of(kobj, struct device, kobj);
4268         struct Scsi_Host *shost = class_to_shost(cdev);
4269         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4270         struct ipr_dump *dump;
4271         unsigned long lock_flags = 0;
4272         char *src;
4273         int len, sdt_end;
4274         size_t rc = count;
4275
4276         if (!capable(CAP_SYS_ADMIN))
4277                 return -EACCES;
4278
4279         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4280         dump = ioa_cfg->dump;
4281
4282         if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
4283                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4284                 return 0;
4285         }
4286         kref_get(&dump->kref);
4287         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4288
4289         if (off > dump->driver_dump.hdr.len) {
4290                 kref_put(&dump->kref, ipr_release_dump);
4291                 return 0;
4292         }
4293
4294         if (off + count > dump->driver_dump.hdr.len) {
4295                 count = dump->driver_dump.hdr.len - off;
4296                 rc = count;
4297         }
4298
4299         if (count && off < sizeof(dump->driver_dump)) {
4300                 if (off + count > sizeof(dump->driver_dump))
4301                         len = sizeof(dump->driver_dump) - off;
4302                 else
4303                         len = count;
4304                 src = (u8 *)&dump->driver_dump + off;
4305                 memcpy(buf, src, len);
4306                 buf += len;
4307                 off += len;
4308                 count -= len;
4309         }
4310
4311         off -= sizeof(dump->driver_dump);
4312
4313         if (ioa_cfg->sis64)
4314                 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4315                           (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
4316                            sizeof(struct ipr_sdt_entry));
4317         else
4318                 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4319                           (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
4320
4321         if (count && off < sdt_end) {
4322                 if (off + count > sdt_end)
4323                         len = sdt_end - off;
4324                 else
4325                         len = count;
4326                 src = (u8 *)&dump->ioa_dump + off;
4327                 memcpy(buf, src, len);
4328                 buf += len;
4329                 off += len;
4330                 count -= len;
4331         }
4332
4333         off -= sdt_end;
4334
4335         while (count) {
4336                 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
4337                         len = PAGE_ALIGN(off) - off;
4338                 else
4339                         len = count;
4340                 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
4341                 src += off & ~PAGE_MASK;
4342                 memcpy(buf, src, len);
4343                 buf += len;
4344                 off += len;
4345                 count -= len;
4346         }
4347
4348         kref_put(&dump->kref, ipr_release_dump);
4349         return rc;
4350 }
4351
4352 /**
4353  * ipr_alloc_dump - Prepare for adapter dump
4354  * @ioa_cfg:    ioa config struct
4355  *
4356  * Return value:
4357  *      0 on success / other on failure
4358  **/
4359 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
4360 {
4361         struct ipr_dump *dump;
4362         __be32 **ioa_data;
4363         unsigned long lock_flags = 0;
4364
4365         dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
4366
4367         if (!dump) {
4368                 ipr_err("Dump memory allocation failed\n");
4369                 return -ENOMEM;
4370         }
4371
4372         if (ioa_cfg->sis64)
4373                 ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES,
4374                                               sizeof(__be32 *)));
4375         else
4376                 ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES,
4377                                               sizeof(__be32 *)));
4378
4379         if (!ioa_data) {
4380                 ipr_err("Dump memory allocation failed\n");
4381                 kfree(dump);
4382                 return -ENOMEM;
4383         }
4384
4385         dump->ioa_dump.ioa_data = ioa_data;
4386
4387         kref_init(&dump->kref);
4388         dump->ioa_cfg = ioa_cfg;
4389
4390         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4391
4392         if (INACTIVE != ioa_cfg->sdt_state) {
4393                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4394                 vfree(dump->ioa_dump.ioa_data);
4395                 kfree(dump);
4396                 return 0;
4397         }
4398
4399         ioa_cfg->dump = dump;
4400         ioa_cfg->sdt_state = WAIT_FOR_DUMP;
4401         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
4402                 ioa_cfg->dump_taken = 1;
4403                 schedule_work(&ioa_cfg->work_q);
4404         }
4405         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4406
4407         return 0;
4408 }
4409
4410 /**
4411  * ipr_free_dump - Free adapter dump memory
4412  * @ioa_cfg:    ioa config struct
4413  *
4414  * Return value:
4415  *      0 on success / other on failure
4416  **/
4417 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4418 {
4419         struct ipr_dump *dump;
4420         unsigned long lock_flags = 0;
4421
4422         ENTER;
4423
4424         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4425         dump = ioa_cfg->dump;
4426         if (!dump) {
4427                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4428                 return 0;
4429         }
4430
4431         ioa_cfg->dump = NULL;
4432         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4433
4434         kref_put(&dump->kref, ipr_release_dump);
4435
4436         LEAVE;
4437         return 0;
4438 }
4439
4440 /**
4441  * ipr_write_dump - Setup dump state of adapter
4442  * @filp:               open sysfs file
4443  * @kobj:               kobject struct
4444  * @bin_attr:           bin_attribute struct
4445  * @buf:                buffer
4446  * @off:                offset
4447  * @count:              buffer size
4448  *
4449  * Return value:
4450  *      number of bytes printed to buffer
4451  **/
4452 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4453                               struct bin_attribute *bin_attr,
4454                               char *buf, loff_t off, size_t count)
4455 {
4456         struct device *cdev = container_of(kobj, struct device, kobj);
4457         struct Scsi_Host *shost = class_to_shost(cdev);
4458         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4459         int rc;
4460
4461         if (!capable(CAP_SYS_ADMIN))
4462                 return -EACCES;
4463
4464         if (buf[0] == '1')
4465                 rc = ipr_alloc_dump(ioa_cfg);
4466         else if (buf[0] == '0')
4467                 rc = ipr_free_dump(ioa_cfg);
4468         else
4469                 return -EINVAL;
4470
4471         if (rc)
4472                 return rc;
4473         else
4474                 return count;
4475 }
4476
4477 static struct bin_attribute ipr_dump_attr = {
4478         .attr = {
4479                 .name = "dump",
4480                 .mode = S_IRUSR | S_IWUSR,
4481         },
4482         .size = 0,
4483         .read = ipr_read_dump,
4484         .write = ipr_write_dump
4485 };
4486 #else
4487 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4488 #endif
4489
4490 /**
4491  * ipr_change_queue_depth - Change the device's queue depth
4492  * @sdev:       scsi device struct
4493  * @qdepth:     depth to set
4494  * @reason:     calling context
4495  *
4496  * Return value:
4497  *      actual depth set
4498  **/
4499 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
4500 {
4501         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4502         struct ipr_resource_entry *res;
4503         unsigned long lock_flags = 0;
4504
4505         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4506         res = (struct ipr_resource_entry *)sdev->hostdata;
4507
4508         if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4509                 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4510         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4511
4512         scsi_change_queue_depth(sdev, qdepth);
4513         return sdev->queue_depth;
4514 }
4515
4516 /**
4517  * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4518  * @dev:        device struct
4519  * @attr:       device attribute structure
4520  * @buf:        buffer
4521  *
4522  * Return value:
4523  *      number of bytes printed to buffer
4524  **/
4525 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4526 {
4527         struct scsi_device *sdev = to_scsi_device(dev);
4528         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4529         struct ipr_resource_entry *res;
4530         unsigned long lock_flags = 0;
4531         ssize_t len = -ENXIO;
4532
4533         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4534         res = (struct ipr_resource_entry *)sdev->hostdata;
4535         if (res)
4536                 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4537         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4538         return len;
4539 }
4540
4541 static struct device_attribute ipr_adapter_handle_attr = {
4542         .attr = {
4543                 .name =         "adapter_handle",
4544                 .mode =         S_IRUSR,
4545         },
4546         .show = ipr_show_adapter_handle
4547 };
4548
4549 /**
4550  * ipr_show_resource_path - Show the resource path or the resource address for
4551  *                          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_resource_path(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         char buffer[IPR_MAX_RES_PATH_LENGTH];
4567
4568         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4569         res = (struct ipr_resource_entry *)sdev->hostdata;
4570         if (res && ioa_cfg->sis64)
4571                 len = snprintf(buf, PAGE_SIZE, "%s\n",
4572                                __ipr_format_res_path(res->res_path, buffer,
4573                                                      sizeof(buffer)));
4574         else if (res)
4575                 len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4576                                res->bus, res->target, res->lun);
4577
4578         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4579         return len;
4580 }
4581
4582 static struct device_attribute ipr_resource_path_attr = {
4583         .attr = {
4584                 .name =         "resource_path",
4585                 .mode =         S_IRUGO,
4586         },
4587         .show = ipr_show_resource_path
4588 };
4589
4590 /**
4591  * ipr_show_device_id - Show the device_id for this device.
4592  * @dev:        device struct
4593  * @attr:       device attribute structure
4594  * @buf:        buffer
4595  *
4596  * Return value:
4597  *      number of bytes printed to buffer
4598  **/
4599 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4600 {
4601         struct scsi_device *sdev = to_scsi_device(dev);
4602         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4603         struct ipr_resource_entry *res;
4604         unsigned long lock_flags = 0;
4605         ssize_t len = -ENXIO;
4606
4607         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4608         res = (struct ipr_resource_entry *)sdev->hostdata;
4609         if (res && ioa_cfg->sis64)
4610                 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id));
4611         else if (res)
4612                 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4613
4614         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4615         return len;
4616 }
4617
4618 static struct device_attribute ipr_device_id_attr = {
4619         .attr = {
4620                 .name =         "device_id",
4621                 .mode =         S_IRUGO,
4622         },
4623         .show = ipr_show_device_id
4624 };
4625
4626 /**
4627  * ipr_show_resource_type - Show the resource type for this device.
4628  * @dev:        device struct
4629  * @attr:       device attribute structure
4630  * @buf:        buffer
4631  *
4632  * Return value:
4633  *      number of bytes printed to buffer
4634  **/
4635 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4636 {
4637         struct scsi_device *sdev = to_scsi_device(dev);
4638         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4639         struct ipr_resource_entry *res;
4640         unsigned long lock_flags = 0;
4641         ssize_t len = -ENXIO;
4642
4643         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4644         res = (struct ipr_resource_entry *)sdev->hostdata;
4645
4646         if (res)
4647                 len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4648
4649         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4650         return len;
4651 }
4652
4653 static struct device_attribute ipr_resource_type_attr = {
4654         .attr = {
4655                 .name =         "resource_type",
4656                 .mode =         S_IRUGO,
4657         },
4658         .show = ipr_show_resource_type
4659 };
4660
4661 /**
4662  * ipr_show_raw_mode - Show the adapter's raw mode
4663  * @dev:        class device struct
4664  * @buf:        buffer
4665  *
4666  * Return value:
4667  *      number of bytes printed to buffer
4668  **/
4669 static ssize_t ipr_show_raw_mode(struct device *dev,
4670                                  struct device_attribute *attr, char *buf)
4671 {
4672         struct scsi_device *sdev = to_scsi_device(dev);
4673         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4674         struct ipr_resource_entry *res;
4675         unsigned long lock_flags = 0;
4676         ssize_t len;
4677
4678         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4679         res = (struct ipr_resource_entry *)sdev->hostdata;
4680         if (res)
4681                 len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode);
4682         else
4683                 len = -ENXIO;
4684         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4685         return len;
4686 }
4687
4688 /**
4689  * ipr_store_raw_mode - Change the adapter's raw mode
4690  * @dev:        class device struct
4691  * @buf:        buffer
4692  *
4693  * Return value:
4694  *      number of bytes printed to buffer
4695  **/
4696 static ssize_t ipr_store_raw_mode(struct device *dev,
4697                                   struct device_attribute *attr,
4698                                   const char *buf, size_t count)
4699 {
4700         struct scsi_device *sdev = to_scsi_device(dev);
4701         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4702         struct ipr_resource_entry *res;
4703         unsigned long lock_flags = 0;
4704         ssize_t len;
4705
4706         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4707         res = (struct ipr_resource_entry *)sdev->hostdata;
4708         if (res) {
4709                 if (ipr_is_af_dasd_device(res)) {
4710                         res->raw_mode = simple_strtoul(buf, NULL, 10);
4711                         len = strlen(buf);
4712                         if (res->sdev)
4713                                 sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n",
4714                                         res->raw_mode ? "enabled" : "disabled");
4715                 } else
4716                         len = -EINVAL;
4717         } else
4718                 len = -ENXIO;
4719         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4720         return len;
4721 }
4722
4723 static struct device_attribute ipr_raw_mode_attr = {
4724         .attr = {
4725                 .name =         "raw_mode",
4726                 .mode =         S_IRUGO | S_IWUSR,
4727         },
4728         .show = ipr_show_raw_mode,
4729         .store = ipr_store_raw_mode
4730 };
4731
4732 static struct device_attribute *ipr_dev_attrs[] = {
4733         &ipr_adapter_handle_attr,
4734         &ipr_resource_path_attr,
4735         &ipr_device_id_attr,
4736         &ipr_resource_type_attr,
4737         &ipr_raw_mode_attr,
4738         NULL,
4739 };
4740
4741 /**
4742  * ipr_biosparam - Return the HSC mapping
4743  * @sdev:                       scsi device struct
4744  * @block_device:       block device pointer
4745  * @capacity:           capacity of the device
4746  * @parm:                       Array containing returned HSC values.
4747  *
4748  * This function generates the HSC parms that fdisk uses.
4749  * We want to make sure we return something that places partitions
4750  * on 4k boundaries for best performance with the IOA.
4751  *
4752  * Return value:
4753  *      0 on success
4754  **/
4755 static int ipr_biosparam(struct scsi_device *sdev,
4756                          struct block_device *block_device,
4757                          sector_t capacity, int *parm)
4758 {
4759         int heads, sectors;
4760         sector_t cylinders;
4761
4762         heads = 128;
4763         sectors = 32;
4764
4765         cylinders = capacity;
4766         sector_div(cylinders, (128 * 32));
4767
4768         /* return result */
4769         parm[0] = heads;
4770         parm[1] = sectors;
4771         parm[2] = cylinders;
4772
4773         return 0;
4774 }
4775
4776 /**
4777  * ipr_find_starget - Find target based on bus/target.
4778  * @starget:    scsi target struct
4779  *
4780  * Return value:
4781  *      resource entry pointer if found / NULL if not found
4782  **/
4783 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4784 {
4785         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4786         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4787         struct ipr_resource_entry *res;
4788
4789         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4790                 if ((res->bus == starget->channel) &&
4791                     (res->target == starget->id)) {
4792                         return res;
4793                 }
4794         }
4795
4796         return NULL;
4797 }
4798
4799 static struct ata_port_info sata_port_info;
4800
4801 /**
4802  * ipr_target_alloc - Prepare for commands to a SCSI target
4803  * @starget:    scsi target struct
4804  *
4805  * If the device is a SATA device, this function allocates an
4806  * ATA port with libata, else it does nothing.
4807  *
4808  * Return value:
4809  *      0 on success / non-0 on failure
4810  **/
4811 static int ipr_target_alloc(struct scsi_target *starget)
4812 {
4813         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4814         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4815         struct ipr_sata_port *sata_port;
4816         struct ata_port *ap;
4817         struct ipr_resource_entry *res;
4818         unsigned long lock_flags;
4819
4820         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4821         res = ipr_find_starget(starget);
4822         starget->hostdata = NULL;
4823
4824         if (res && ipr_is_gata(res)) {
4825                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4826                 sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4827                 if (!sata_port)
4828                         return -ENOMEM;
4829
4830                 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4831                 if (ap) {
4832                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4833                         sata_port->ioa_cfg = ioa_cfg;
4834                         sata_port->ap = ap;
4835                         sata_port->res = res;
4836
4837                         res->sata_port = sata_port;
4838                         ap->private_data = sata_port;
4839                         starget->hostdata = sata_port;
4840                 } else {
4841                         kfree(sata_port);
4842                         return -ENOMEM;
4843                 }
4844         }
4845         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4846
4847         return 0;
4848 }
4849
4850 /**
4851  * ipr_target_destroy - Destroy a SCSI target
4852  * @starget:    scsi target struct
4853  *
4854  * If the device was a SATA device, this function frees the libata
4855  * ATA port, else it does nothing.
4856  *
4857  **/
4858 static void ipr_target_destroy(struct scsi_target *starget)
4859 {
4860         struct ipr_sata_port *sata_port = starget->hostdata;
4861         struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4862         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4863
4864         if (ioa_cfg->sis64) {
4865                 if (!ipr_find_starget(starget)) {
4866                         if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4867                                 clear_bit(starget->id, ioa_cfg->array_ids);
4868                         else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4869                                 clear_bit(starget->id, ioa_cfg->vset_ids);
4870                         else if (starget->channel == 0)
4871                                 clear_bit(starget->id, ioa_cfg->target_ids);
4872                 }
4873         }
4874
4875         if (sata_port) {
4876                 starget->hostdata = NULL;
4877                 ata_sas_port_destroy(sata_port->ap);
4878                 kfree(sata_port);
4879         }
4880 }
4881
4882 /**
4883  * ipr_find_sdev - Find device based on bus/target/lun.
4884  * @sdev:       scsi device struct
4885  *
4886  * Return value:
4887  *      resource entry pointer if found / NULL if not found
4888  **/
4889 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4890 {
4891         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4892         struct ipr_resource_entry *res;
4893
4894         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4895                 if ((res->bus == sdev->channel) &&
4896                     (res->target == sdev->id) &&
4897                     (res->lun == sdev->lun))
4898                         return res;
4899         }
4900
4901         return NULL;
4902 }
4903
4904 /**
4905  * ipr_slave_destroy - Unconfigure a SCSI device
4906  * @sdev:       scsi device struct
4907  *
4908  * Return value:
4909  *      nothing
4910  **/
4911 static void ipr_slave_destroy(struct scsi_device *sdev)
4912 {
4913         struct ipr_resource_entry *res;
4914         struct ipr_ioa_cfg *ioa_cfg;
4915         unsigned long lock_flags = 0;
4916
4917         ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4918
4919         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4920         res = (struct ipr_resource_entry *) sdev->hostdata;
4921         if (res) {
4922                 if (res->sata_port)
4923                         res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4924                 sdev->hostdata = NULL;
4925                 res->sdev = NULL;
4926                 res->sata_port = NULL;
4927         }
4928         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4929 }
4930
4931 /**
4932  * ipr_slave_configure - Configure a SCSI device
4933  * @sdev:       scsi device struct
4934  *
4935  * This function configures the specified scsi device.
4936  *
4937  * Return value:
4938  *      0 on success
4939  **/
4940 static int ipr_slave_configure(struct scsi_device *sdev)
4941 {
4942         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4943         struct ipr_resource_entry *res;
4944         struct ata_port *ap = NULL;
4945         unsigned long lock_flags = 0;
4946         char buffer[IPR_MAX_RES_PATH_LENGTH];
4947
4948         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4949         res = sdev->hostdata;
4950         if (res) {
4951                 if (ipr_is_af_dasd_device(res))
4952                         sdev->type = TYPE_RAID;
4953                 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4954                         sdev->scsi_level = 4;
4955                         sdev->no_uld_attach = 1;
4956                 }
4957                 if (ipr_is_vset_device(res)) {
4958                         sdev->scsi_level = SCSI_SPC_3;
4959                         sdev->no_report_opcodes = 1;
4960                         blk_queue_rq_timeout(sdev->request_queue,
4961                                              IPR_VSET_RW_TIMEOUT);
4962                         blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4963                 }
4964                 if (ipr_is_gata(res) && res->sata_port)
4965                         ap = res->sata_port->ap;
4966                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4967
4968                 if (ap) {
4969                         scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
4970                         ata_sas_slave_configure(sdev, ap);
4971                 }
4972
4973                 if (ioa_cfg->sis64)
4974                         sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4975                                     ipr_format_res_path(ioa_cfg,
4976                                 res->res_path, buffer, sizeof(buffer)));
4977                 return 0;
4978         }
4979         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4980         return 0;
4981 }
4982
4983 /**
4984  * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4985  * @sdev:       scsi device struct
4986  *
4987  * This function initializes an ATA port so that future commands
4988  * sent through queuecommand will work.
4989  *
4990  * Return value:
4991  *      0 on success
4992  **/
4993 static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4994 {
4995         struct ipr_sata_port *sata_port = NULL;
4996         int rc = -ENXIO;
4997
4998         ENTER;
4999         if (sdev->sdev_target)
5000                 sata_port = sdev->sdev_target->hostdata;
5001         if (sata_port) {
5002                 rc = ata_sas_port_init(sata_port->ap);
5003                 if (rc == 0)
5004                         rc = ata_sas_sync_probe(sata_port->ap);
5005         }
5006
5007         if (rc)
5008                 ipr_slave_destroy(sdev);
5009
5010         LEAVE;
5011         return rc;
5012 }
5013
5014 /**
5015  * ipr_slave_alloc - Prepare for commands to a device.
5016  * @sdev:       scsi device struct
5017  *
5018  * This function saves a pointer to the resource entry
5019  * in the scsi device struct if the device exists. We
5020  * can then use this pointer in ipr_queuecommand when
5021  * handling new commands.
5022  *
5023  * Return value:
5024  *      0 on success / -ENXIO if device does not exist
5025  **/
5026 static int ipr_slave_alloc(struct scsi_device *sdev)
5027 {
5028         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
5029         struct ipr_resource_entry *res;
5030         unsigned long lock_flags;
5031         int rc = -ENXIO;
5032
5033         sdev->hostdata = NULL;
5034
5035         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5036
5037         res = ipr_find_sdev(sdev);
5038         if (res) {
5039                 res->sdev = sdev;
5040                 res->add_to_ml = 0;
5041                 res->in_erp = 0;
5042                 sdev->hostdata = res;
5043                 if (!ipr_is_naca_model(res))
5044                         res->needs_sync_complete = 1;
5045                 rc = 0;
5046                 if (ipr_is_gata(res)) {
5047                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5048                         return ipr_ata_slave_alloc(sdev);
5049                 }
5050         }
5051
5052         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5053
5054         return rc;
5055 }
5056
5057 /**
5058  * ipr_match_lun - Match function for specified LUN
5059  * @ipr_cmd:    ipr command struct
5060  * @device:             device to match (sdev)
5061  *
5062  * Returns:
5063  *      1 if command matches sdev / 0 if command does not match sdev
5064  **/
5065 static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device)
5066 {
5067         if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device)
5068                 return 1;
5069         return 0;
5070 }
5071
5072 /**
5073  * ipr_cmnd_is_free - Check if a command is free or not
5074  * @ipr_cmd     ipr command struct
5075  *
5076  * Returns:
5077  *      true / false
5078  **/
5079 static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd)
5080 {
5081         struct ipr_cmnd *loop_cmd;
5082
5083         list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) {
5084                 if (loop_cmd == ipr_cmd)
5085                         return true;
5086         }
5087
5088         return false;
5089 }
5090
5091 /**
5092  * ipr_match_res - Match function for specified resource entry
5093  * @ipr_cmd:    ipr command struct
5094  * @resource:   resource entry to match
5095  *
5096  * Returns:
5097  *      1 if command matches sdev / 0 if command does not match sdev
5098  **/
5099 static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource)
5100 {
5101         struct ipr_resource_entry *res = resource;
5102
5103         if (res && ipr_cmd->ioarcb.res_handle == res->res_handle)
5104                 return 1;
5105         return 0;
5106 }
5107
5108 /**
5109  * ipr_wait_for_ops - Wait for matching commands to complete
5110  * @ipr_cmd:    ipr command struct
5111  * @device:             device to match (sdev)
5112  * @match:              match function to use
5113  *
5114  * Returns:
5115  *      SUCCESS / FAILED
5116  **/
5117 static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device,
5118                             int (*match)(struct ipr_cmnd *, void *))
5119 {
5120         struct ipr_cmnd *ipr_cmd;
5121         int wait, i;
5122         unsigned long flags;
5123         struct ipr_hrr_queue *hrrq;
5124         signed long timeout = IPR_ABORT_TASK_TIMEOUT;
5125         DECLARE_COMPLETION_ONSTACK(comp);
5126
5127         ENTER;
5128         do {
5129                 wait = 0;
5130
5131                 for_each_hrrq(hrrq, ioa_cfg) {
5132                         spin_lock_irqsave(hrrq->lock, flags);
5133                         for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5134                                 ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5135                                 if (!ipr_cmnd_is_free(ipr_cmd)) {
5136                                         if (match(ipr_cmd, device)) {
5137                                                 ipr_cmd->eh_comp = &comp;
5138                                                 wait++;
5139                                         }
5140                                 }
5141                         }
5142                         spin_unlock_irqrestore(hrrq->lock, flags);
5143                 }
5144
5145                 if (wait) {
5146                         timeout = wait_for_completion_timeout(&comp, timeout);
5147
5148                         if (!timeout) {
5149                                 wait = 0;
5150
5151                                 for_each_hrrq(hrrq, ioa_cfg) {
5152                                         spin_lock_irqsave(hrrq->lock, flags);
5153                                         for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5154                                                 ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5155                                                 if (!ipr_cmnd_is_free(ipr_cmd)) {
5156                                                         if (match(ipr_cmd, device)) {
5157                                                                 ipr_cmd->eh_comp = NULL;
5158                                                                 wait++;
5159                                                         }
5160                                                 }
5161                                         }
5162                                         spin_unlock_irqrestore(hrrq->lock, flags);
5163                                 }
5164
5165                                 if (wait)
5166                                         dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n");
5167                                 LEAVE;
5168                                 return wait ? FAILED : SUCCESS;
5169                         }
5170                 }
5171         } while (wait);
5172
5173         LEAVE;
5174         return SUCCESS;
5175 }
5176
5177 static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
5178 {
5179         struct ipr_ioa_cfg *ioa_cfg;
5180         unsigned long lock_flags = 0;
5181         int rc = SUCCESS;
5182
5183         ENTER;
5184         ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5185         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5186
5187         if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5188                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5189                 dev_err(&ioa_cfg->pdev->dev,
5190                         "Adapter being reset as a result of error recovery.\n");
5191
5192                 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5193                         ioa_cfg->sdt_state = GET_DUMP;
5194         }
5195
5196         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5197         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5198         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5199
5200         /* If we got hit with a host reset while we were already resetting
5201          the adapter for some reason, and the reset failed. */
5202         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
5203                 ipr_trace;
5204                 rc = FAILED;
5205         }
5206
5207         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5208         LEAVE;
5209         return rc;
5210 }
5211
5212 /**
5213  * ipr_device_reset - Reset the device
5214  * @ioa_cfg:    ioa config struct
5215  * @res:                resource entry struct
5216  *
5217  * This function issues a device reset to the affected device.
5218  * If the device is a SCSI device, a LUN reset will be sent
5219  * to the device first. If that does not work, a target reset
5220  * will be sent. If the device is a SATA device, a PHY reset will
5221  * be sent.
5222  *
5223  * Return value:
5224  *      0 on success / non-zero on failure
5225  **/
5226 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
5227                             struct ipr_resource_entry *res)
5228 {
5229         struct ipr_cmnd *ipr_cmd;
5230         struct ipr_ioarcb *ioarcb;
5231         struct ipr_cmd_pkt *cmd_pkt;
5232         struct ipr_ioarcb_ata_regs *regs;
5233         u32 ioasc;
5234
5235         ENTER;
5236         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5237         ioarcb = &ipr_cmd->ioarcb;
5238         cmd_pkt = &ioarcb->cmd_pkt;
5239
5240         if (ipr_cmd->ioa_cfg->sis64) {
5241                 regs = &ipr_cmd->i.ata_ioadl.regs;
5242                 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
5243         } else
5244                 regs = &ioarcb->u.add_data.u.regs;
5245
5246         ioarcb->res_handle = res->res_handle;
5247         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5248         cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5249         if (ipr_is_gata(res)) {
5250                 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
5251                 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
5252                 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
5253         }
5254
5255         ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5256         ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5257         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5258         if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
5259                 if (ipr_cmd->ioa_cfg->sis64)
5260                         memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
5261                                sizeof(struct ipr_ioasa_gata));
5262                 else
5263                         memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
5264                                sizeof(struct ipr_ioasa_gata));
5265         }
5266
5267         LEAVE;
5268         return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
5269 }
5270
5271 /**
5272  * ipr_sata_reset - Reset the SATA port
5273  * @link:       SATA link to reset
5274  * @classes:    class of the attached device
5275  *
5276  * This function issues a SATA phy reset to the affected ATA link.
5277  *
5278  * Return value:
5279  *      0 on success / non-zero on failure
5280  **/
5281 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
5282                                 unsigned long deadline)
5283 {
5284         struct ipr_sata_port *sata_port = link->ap->private_data;
5285         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
5286         struct ipr_resource_entry *res;
5287         unsigned long lock_flags = 0;
5288         int rc = -ENXIO, ret;
5289
5290         ENTER;
5291         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5292         while (ioa_cfg->in_reset_reload) {
5293                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5294                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5295                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5296         }
5297
5298         res = sata_port->res;
5299         if (res) {
5300                 rc = ipr_device_reset(ioa_cfg, res);
5301                 *classes = res->ata_class;
5302                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5303
5304                 ret = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5305                 if (ret != SUCCESS) {
5306                         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5307                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
5308                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5309
5310                         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5311                 }
5312         } else
5313                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5314
5315         LEAVE;
5316         return rc;
5317 }
5318
5319 /**
5320  * ipr_eh_dev_reset - Reset the device
5321  * @scsi_cmd:   scsi command struct
5322  *
5323  * This function issues a device reset to the affected device.
5324  * A LUN reset will be sent to the device first. If that does
5325  * not work, a target reset will be sent.
5326  *
5327  * Return value:
5328  *      SUCCESS / FAILED
5329  **/
5330 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
5331 {
5332         struct ipr_cmnd *ipr_cmd;
5333         struct ipr_ioa_cfg *ioa_cfg;
5334         struct ipr_resource_entry *res;
5335         struct ata_port *ap;
5336         int rc = 0, i;
5337         struct ipr_hrr_queue *hrrq;
5338
5339         ENTER;
5340         ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5341         res = scsi_cmd->device->hostdata;
5342
5343         /*
5344          * If we are currently going through reset/reload, return failed. This will force the
5345          * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
5346          * reset to complete
5347          */
5348         if (ioa_cfg->in_reset_reload)
5349                 return FAILED;
5350         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5351                 return FAILED;
5352
5353         for_each_hrrq(hrrq, ioa_cfg) {
5354                 spin_lock(&hrrq->_lock);
5355                 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5356                         ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
5357
5358                         if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
5359                                 if (!ipr_cmd->qc)
5360                                         continue;
5361                                 if (ipr_cmnd_is_free(ipr_cmd))
5362                                         continue;
5363
5364                                 ipr_cmd->done = ipr_sata_eh_done;
5365                                 if (!(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
5366                                         ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
5367                                         ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
5368                                 }
5369                         }
5370                 }
5371                 spin_unlock(&hrrq->_lock);
5372         }
5373         res->resetting_device = 1;
5374         scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
5375
5376         if (ipr_is_gata(res) && res->sata_port) {
5377                 ap = res->sata_port->ap;
5378                 spin_unlock_irq(scsi_cmd->device->host->host_lock);
5379                 ata_std_error_handler(ap);
5380                 spin_lock_irq(scsi_cmd->device->host->host_lock);
5381         } else
5382                 rc = ipr_device_reset(ioa_cfg, res);
5383         res->resetting_device = 0;
5384         res->reset_occurred = 1;
5385
5386         LEAVE;
5387         return rc ? FAILED : SUCCESS;
5388 }
5389
5390 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
5391 {
5392         int rc;
5393         struct ipr_ioa_cfg *ioa_cfg;
5394         struct ipr_resource_entry *res;
5395
5396         ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
5397         res = cmd->device->hostdata;
5398
5399         if (!res)
5400                 return FAILED;
5401
5402         spin_lock_irq(cmd->device->host->host_lock);
5403         rc = __ipr_eh_dev_reset(cmd);
5404         spin_unlock_irq(cmd->device->host->host_lock);
5405
5406         if (rc == SUCCESS) {
5407                 if (ipr_is_gata(res) && res->sata_port)
5408                         rc = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
5409                 else
5410                         rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun);
5411         }
5412
5413         return rc;
5414 }
5415
5416 /**
5417  * ipr_bus_reset_done - Op done function for bus reset.
5418  * @ipr_cmd:    ipr command struct
5419  *
5420  * This function is the op done function for a bus reset
5421  *
5422  * Return value:
5423  *      none
5424  **/
5425 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
5426 {
5427         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5428         struct ipr_resource_entry *res;
5429
5430         ENTER;
5431         if (!ioa_cfg->sis64)
5432                 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
5433                         if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
5434                                 scsi_report_bus_reset(ioa_cfg->host, res->bus);
5435                                 break;
5436                         }
5437                 }
5438
5439         /*
5440          * If abort has not completed, indicate the reset has, else call the
5441          * abort's done function to wake the sleeping eh thread
5442          */
5443         if (ipr_cmd->sibling->sibling)
5444                 ipr_cmd->sibling->sibling = NULL;
5445         else
5446                 ipr_cmd->sibling->done(ipr_cmd->sibling);
5447
5448         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5449         LEAVE;
5450 }
5451
5452 /**
5453  * ipr_abort_timeout - An abort task has timed out
5454  * @ipr_cmd:    ipr command struct
5455  *
5456  * This function handles when an abort task times out. If this
5457  * happens we issue a bus reset since we have resources tied
5458  * up that must be freed before returning to the midlayer.
5459  *
5460  * Return value:
5461  *      none
5462  **/
5463 static void ipr_abort_timeout(struct timer_list *t)
5464 {
5465         struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
5466         struct ipr_cmnd *reset_cmd;
5467         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5468         struct ipr_cmd_pkt *cmd_pkt;
5469         unsigned long lock_flags = 0;
5470
5471         ENTER;
5472         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5473         if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
5474                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5475                 return;
5476         }
5477
5478         sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
5479         reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5480         ipr_cmd->sibling = reset_cmd;
5481         reset_cmd->sibling = ipr_cmd;
5482         reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
5483         cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
5484         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5485         cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5486         cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
5487
5488         ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5489         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5490         LEAVE;
5491 }
5492
5493 /**
5494  * ipr_cancel_op - Cancel specified op
5495  * @scsi_cmd:   scsi command struct
5496  *
5497  * This function cancels specified op.
5498  *
5499  * Return value:
5500  *      SUCCESS / FAILED
5501  **/
5502 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
5503 {
5504         struct ipr_cmnd *ipr_cmd;
5505         struct ipr_ioa_cfg *ioa_cfg;
5506         struct ipr_resource_entry *res;
5507         struct ipr_cmd_pkt *cmd_pkt;
5508         u32 ioasc, int_reg;
5509         int i, op_found = 0;
5510         struct ipr_hrr_queue *hrrq;
5511
5512         ENTER;
5513         ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5514         res = scsi_cmd->device->hostdata;
5515
5516         /* If we are currently going through reset/reload, return failed.
5517          * This will force the mid-layer to call ipr_eh_host_reset,
5518          * which will then go to sleep and wait for the reset to complete
5519          */
5520         if (ioa_cfg->in_reset_reload ||
5521             ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5522                 return FAILED;
5523         if (!res)
5524                 return FAILED;
5525
5526         /*
5527          * If we are aborting a timed out op, chances are that the timeout was caused
5528          * by a still not detected EEH error. In such cases, reading a register will
5529          * trigger the EEH recovery infrastructure.
5530          */
5531         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5532
5533         if (!ipr_is_gscsi(res))
5534                 return FAILED;
5535
5536         for_each_hrrq(hrrq, ioa_cfg) {
5537                 spin_lock(&hrrq->_lock);
5538                 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
5539                         if (ioa_cfg->ipr_cmnd_list[i]->scsi_cmd == scsi_cmd) {
5540                                 if (!ipr_cmnd_is_free(ioa_cfg->ipr_cmnd_list[i])) {
5541                                         op_found = 1;
5542                                         break;
5543                                 }
5544                         }
5545                 }
5546                 spin_unlock(&hrrq->_lock);
5547         }
5548
5549         if (!op_found)
5550                 return SUCCESS;
5551
5552         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5553         ipr_cmd->ioarcb.res_handle = res->res_handle;
5554         cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5555         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5556         cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
5557         ipr_cmd->u.sdev = scsi_cmd->device;
5558
5559         scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
5560                     scsi_cmd->cmnd[0]);
5561         ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
5562         ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5563
5564         /*
5565          * If the abort task timed out and we sent a bus reset, we will get
5566          * one the following responses to the abort
5567          */
5568         if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
5569                 ioasc = 0;
5570                 ipr_trace;
5571         }
5572
5573         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5574         if (!ipr_is_naca_model(res))
5575                 res->needs_sync_complete = 1;
5576
5577         LEAVE;
5578         return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
5579 }
5580
5581 /**
5582  * ipr_eh_abort - Abort a single op
5583  * @scsi_cmd:   scsi command struct
5584  *
5585  * Return value:
5586  *      0 if scan in progress / 1 if scan is complete
5587  **/
5588 static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time)
5589 {
5590         unsigned long lock_flags;
5591         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
5592         int rc = 0;
5593
5594         spin_lock_irqsave(shost->host_lock, lock_flags);
5595         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done)
5596                 rc = 1;
5597         if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2))
5598                 rc = 1;
5599         spin_unlock_irqrestore(shost->host_lock, lock_flags);
5600         return rc;
5601 }
5602
5603 /**
5604  * ipr_eh_host_reset - Reset the host adapter
5605  * @scsi_cmd:   scsi command struct
5606  *
5607  * Return value:
5608  *      SUCCESS / FAILED
5609  **/
5610 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
5611 {
5612         unsigned long flags;
5613         int rc;
5614         struct ipr_ioa_cfg *ioa_cfg;
5615
5616         ENTER;
5617
5618         ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
5619
5620         spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
5621         rc = ipr_cancel_op(scsi_cmd);
5622         spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
5623
5624         if (rc == SUCCESS)
5625                 rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun);
5626         LEAVE;
5627         return rc;
5628 }
5629
5630 /**
5631  * ipr_handle_other_interrupt - Handle "other" interrupts
5632  * @ioa_cfg:    ioa config struct
5633  * @int_reg:    interrupt register
5634  *
5635  * Return value:
5636  *      IRQ_NONE / IRQ_HANDLED
5637  **/
5638 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5639                                               u32 int_reg)
5640 {
5641         irqreturn_t rc = IRQ_HANDLED;
5642         u32 int_mask_reg;
5643
5644         int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5645         int_reg &= ~int_mask_reg;
5646
5647         /* If an interrupt on the adapter did not occur, ignore it.
5648          * Or in the case of SIS 64, check for a stage change interrupt.
5649          */
5650         if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
5651                 if (ioa_cfg->sis64) {
5652                         int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5653                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5654                         if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
5655
5656                                 /* clear stage change */
5657                                 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
5658                                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5659                                 list_del(&ioa_cfg->reset_cmd->queue);
5660                                 del_timer(&ioa_cfg->reset_cmd->timer);
5661                                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5662                                 return IRQ_HANDLED;
5663                         }
5664                 }
5665
5666                 return IRQ_NONE;
5667         }
5668
5669         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5670                 /* Mask the interrupt */
5671                 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
5672                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5673
5674                 list_del(&ioa_cfg->reset_cmd->queue);
5675                 del_timer(&ioa_cfg->reset_cmd->timer);
5676                 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5677         } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
5678                 if (ioa_cfg->clear_isr) {
5679                         if (ipr_debug && printk_ratelimit())
5680                                 dev_err(&ioa_cfg->pdev->dev,
5681                                         "Spurious interrupt detected. 0x%08X\n", int_reg);
5682                         writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
5683                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5684                         return IRQ_NONE;
5685                 }
5686         } else {
5687                 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
5688                         ioa_cfg->ioa_unit_checked = 1;
5689                 else if (int_reg & IPR_PCII_NO_HOST_RRQ)
5690                         dev_err(&ioa_cfg->pdev->dev,
5691                                 "No Host RRQ. 0x%08X\n", int_reg);
5692                 else
5693                         dev_err(&ioa_cfg->pdev->dev,
5694                                 "Permanent IOA failure. 0x%08X\n", int_reg);
5695
5696                 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5697                         ioa_cfg->sdt_state = GET_DUMP;
5698
5699                 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
5700                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5701         }
5702
5703         return rc;
5704 }
5705
5706 /**
5707  * ipr_isr_eh - Interrupt service routine error handler
5708  * @ioa_cfg:    ioa config struct
5709  * @msg:        message to log
5710  *
5711  * Return value:
5712  *      none
5713  **/
5714 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number)
5715 {
5716         ioa_cfg->errors_logged++;
5717         dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number);
5718
5719         if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
5720                 ioa_cfg->sdt_state = GET_DUMP;
5721
5722         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5723 }
5724
5725 static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget,
5726                                                 struct list_head *doneq)
5727 {
5728         u32 ioasc;
5729         u16 cmd_index;
5730         struct ipr_cmnd *ipr_cmd;
5731         struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg;
5732         int num_hrrq = 0;
5733
5734         /* If interrupts are disabled, ignore the interrupt */
5735         if (!hrr_queue->allow_interrupts)
5736                 return 0;
5737
5738         while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5739                hrr_queue->toggle_bit) {
5740
5741                 cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) &
5742                              IPR_HRRQ_REQ_RESP_HANDLE_MASK) >>
5743                              IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
5744
5745                 if (unlikely(cmd_index > hrr_queue->max_cmd_id ||
5746                              cmd_index < hrr_queue->min_cmd_id)) {
5747                         ipr_isr_eh(ioa_cfg,
5748                                 "Invalid response handle from IOA: ",
5749                                 cmd_index);
5750                         break;
5751                 }
5752
5753                 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
5754                 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5755
5756                 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
5757
5758                 list_move_tail(&ipr_cmd->queue, doneq);
5759
5760                 if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) {
5761                         hrr_queue->hrrq_curr++;
5762                 } else {
5763                         hrr_queue->hrrq_curr = hrr_queue->hrrq_start;
5764                         hrr_queue->toggle_bit ^= 1u;
5765                 }
5766                 num_hrrq++;
5767                 if (budget > 0 && num_hrrq >= budget)
5768                         break;
5769         }
5770
5771         return num_hrrq;
5772 }
5773
5774 static int ipr_iopoll(struct irq_poll *iop, int budget)
5775 {
5776         struct ipr_ioa_cfg *ioa_cfg;
5777         struct ipr_hrr_queue *hrrq;
5778         struct ipr_cmnd *ipr_cmd, *temp;
5779         unsigned long hrrq_flags;
5780         int completed_ops;
5781         LIST_HEAD(doneq);
5782
5783         hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
5784         ioa_cfg = hrrq->ioa_cfg;
5785
5786         spin_lock_irqsave(hrrq->lock, hrrq_flags);
5787         completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
5788
5789         if (completed_ops < budget)
5790                 irq_poll_complete(iop);
5791         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5792
5793         list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5794                 list_del(&ipr_cmd->queue);
5795                 del_timer(&ipr_cmd->timer);
5796                 ipr_cmd->fast_done(ipr_cmd);
5797         }
5798
5799         return completed_ops;
5800 }
5801
5802 /**
5803  * ipr_isr - Interrupt service routine
5804  * @irq:        irq number
5805  * @devp:       pointer to ioa config struct
5806  *
5807  * Return value:
5808  *      IRQ_NONE / IRQ_HANDLED
5809  **/
5810 static irqreturn_t ipr_isr(int irq, void *devp)
5811 {
5812         struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5813         struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5814         unsigned long hrrq_flags = 0;
5815         u32 int_reg = 0;
5816         int num_hrrq = 0;
5817         int irq_none = 0;
5818         struct ipr_cmnd *ipr_cmd, *temp;
5819         irqreturn_t rc = IRQ_NONE;
5820         LIST_HEAD(doneq);
5821
5822         spin_lock_irqsave(hrrq->lock, hrrq_flags);
5823         /* If interrupts are disabled, ignore the interrupt */
5824         if (!hrrq->allow_interrupts) {
5825                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5826                 return IRQ_NONE;
5827         }
5828
5829         while (1) {
5830                 if (ipr_process_hrrq(hrrq, -1, &doneq)) {
5831                         rc =  IRQ_HANDLED;
5832
5833                         if (!ioa_cfg->clear_isr)
5834                                 break;
5835
5836                         /* Clear the PCI interrupt */
5837                         num_hrrq = 0;
5838                         do {
5839                                 writel(IPR_PCII_HRRQ_UPDATED,
5840                                      ioa_cfg->regs.clr_interrupt_reg32);
5841                                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5842                         } while (int_reg & IPR_PCII_HRRQ_UPDATED &&
5843                                 num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
5844
5845                 } else if (rc == IRQ_NONE && irq_none == 0) {
5846                         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
5847                         irq_none++;
5848                 } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
5849                            int_reg & IPR_PCII_HRRQ_UPDATED) {
5850                         ipr_isr_eh(ioa_cfg,
5851                                 "Error clearing HRRQ: ", num_hrrq);
5852                         rc = IRQ_HANDLED;
5853                         break;
5854                 } else
5855                         break;
5856         }
5857
5858         if (unlikely(rc == IRQ_NONE))
5859                 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
5860
5861         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5862         list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5863                 list_del(&ipr_cmd->queue);
5864                 del_timer(&ipr_cmd->timer);
5865                 ipr_cmd->fast_done(ipr_cmd);
5866         }
5867         return rc;
5868 }
5869
5870 /**
5871  * ipr_isr_mhrrq - Interrupt service routine
5872  * @irq:        irq number
5873  * @devp:       pointer to ioa config struct
5874  *
5875  * Return value:
5876  *      IRQ_NONE / IRQ_HANDLED
5877  **/
5878 static irqreturn_t ipr_isr_mhrrq(int irq, void *devp)
5879 {
5880         struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
5881         struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
5882         unsigned long hrrq_flags = 0;
5883         struct ipr_cmnd *ipr_cmd, *temp;
5884         irqreturn_t rc = IRQ_NONE;
5885         LIST_HEAD(doneq);
5886
5887         spin_lock_irqsave(hrrq->lock, hrrq_flags);
5888
5889         /* If interrupts are disabled, ignore the interrupt */
5890         if (!hrrq->allow_interrupts) {
5891                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5892                 return IRQ_NONE;
5893         }
5894
5895         if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
5896                 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5897                        hrrq->toggle_bit) {
5898                         irq_poll_sched(&hrrq->iopoll);
5899                         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5900                         return IRQ_HANDLED;
5901                 }
5902         } else {
5903                 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
5904                         hrrq->toggle_bit)
5905
5906                         if (ipr_process_hrrq(hrrq, -1, &doneq))
5907                                 rc =  IRQ_HANDLED;
5908         }
5909
5910         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
5911
5912         list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
5913                 list_del(&ipr_cmd->queue);
5914                 del_timer(&ipr_cmd->timer);
5915                 ipr_cmd->fast_done(ipr_cmd);
5916         }
5917         return rc;
5918 }
5919
5920 /**
5921  * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
5922  * @ioa_cfg:    ioa config struct
5923  * @ipr_cmd:    ipr command struct
5924  *
5925  * Return value:
5926  *      0 on success / -1 on failure
5927  **/
5928 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
5929                              struct ipr_cmnd *ipr_cmd)
5930 {
5931         int i, nseg;
5932         struct scatterlist *sg;
5933         u32 length;
5934         u32 ioadl_flags = 0;
5935         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5936         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5937         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
5938
5939         length = scsi_bufflen(scsi_cmd);
5940         if (!length)
5941                 return 0;
5942
5943         nseg = scsi_dma_map(scsi_cmd);
5944         if (nseg < 0) {
5945                 if (printk_ratelimit())
5946                         dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5947                 return -1;
5948         }
5949
5950         ipr_cmd->dma_use_sg = nseg;
5951
5952         ioarcb->data_transfer_length = cpu_to_be32(length);
5953         ioarcb->ioadl_len =
5954                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
5955
5956         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
5957                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5958                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5959         } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
5960                 ioadl_flags = IPR_IOADL_FLAGS_READ;
5961
5962         scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
5963                 ioadl64[i].flags = cpu_to_be32(ioadl_flags);
5964                 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
5965                 ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
5966         }
5967
5968         ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5969         return 0;
5970 }
5971
5972 /**
5973  * ipr_build_ioadl - Build a scatter/gather list and map the buffer
5974  * @ioa_cfg:    ioa config struct
5975  * @ipr_cmd:    ipr command struct
5976  *
5977  * Return value:
5978  *      0 on success / -1 on failure
5979  **/
5980 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
5981                            struct ipr_cmnd *ipr_cmd)
5982 {
5983         int i, nseg;
5984         struct scatterlist *sg;
5985         u32 length;
5986         u32 ioadl_flags = 0;
5987         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
5988         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5989         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
5990
5991         length = scsi_bufflen(scsi_cmd);
5992         if (!length)
5993                 return 0;
5994
5995         nseg = scsi_dma_map(scsi_cmd);
5996         if (nseg < 0) {
5997                 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
5998                 return -1;
5999         }
6000
6001         ipr_cmd->dma_use_sg = nseg;
6002
6003         if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
6004                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6005                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6006                 ioarcb->data_transfer_length = cpu_to_be32(length);
6007                 ioarcb->ioadl_len =
6008                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6009         } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
6010                 ioadl_flags = IPR_IOADL_FLAGS_READ;
6011                 ioarcb->read_data_transfer_length = cpu_to_be32(length);
6012                 ioarcb->read_ioadl_len =
6013                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6014         }
6015
6016         if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
6017                 ioadl = ioarcb->u.add_data.u.ioadl;
6018                 ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
6019                                     offsetof(struct ipr_ioarcb, u.add_data));
6020                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6021         }
6022
6023         scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
6024                 ioadl[i].flags_and_data_len =
6025                         cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6026                 ioadl[i].address = cpu_to_be32(sg_dma_address(sg));
6027         }
6028
6029         ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6030         return 0;
6031 }
6032
6033 /**
6034  * __ipr_erp_done - Process completion of ERP for a device
6035  * @ipr_cmd:            ipr command struct
6036  *
6037  * This function copies the sense buffer into the scsi_cmd
6038  * struct and pushes the scsi_done function.
6039  *
6040  * Return value:
6041  *      nothing
6042  **/
6043 static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6044 {
6045         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6046         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6047         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6048
6049         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6050                 scsi_cmd->result |= (DID_ERROR << 16);
6051                 scmd_printk(KERN_ERR, scsi_cmd,
6052                             "Request Sense failed with IOASC: 0x%08X\n", ioasc);
6053         } else {
6054                 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
6055                        SCSI_SENSE_BUFFERSIZE);
6056         }
6057
6058         if (res) {
6059                 if (!ipr_is_naca_model(res))
6060                         res->needs_sync_complete = 1;
6061                 res->in_erp = 0;
6062         }
6063         scsi_dma_unmap(ipr_cmd->scsi_cmd);
6064         scsi_cmd->scsi_done(scsi_cmd);
6065         if (ipr_cmd->eh_comp)
6066                 complete(ipr_cmd->eh_comp);
6067         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6068 }
6069
6070 /**
6071  * ipr_erp_done - Process completion of ERP for a device
6072  * @ipr_cmd:            ipr command struct
6073  *
6074  * This function copies the sense buffer into the scsi_cmd
6075  * struct and pushes the scsi_done function.
6076  *
6077  * Return value:
6078  *      nothing
6079  **/
6080 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
6081 {
6082         struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6083         unsigned long hrrq_flags;
6084
6085         spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6086         __ipr_erp_done(ipr_cmd);
6087         spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6088 }
6089
6090 /**
6091  * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
6092  * @ipr_cmd:    ipr command struct
6093  *
6094  * Return value:
6095  *      none
6096  **/
6097 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
6098 {
6099         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6100         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6101         dma_addr_t dma_addr = ipr_cmd->dma_addr;
6102
6103         memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
6104         ioarcb->data_transfer_length = 0;
6105         ioarcb->read_data_transfer_length = 0;
6106         ioarcb->ioadl_len = 0;
6107         ioarcb->read_ioadl_len = 0;
6108         ioasa->hdr.ioasc = 0;
6109         ioasa->hdr.residual_data_len = 0;
6110
6111         if (ipr_cmd->ioa_cfg->sis64)
6112                 ioarcb->u.sis64_addr_data.data_ioadl_addr =
6113                         cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
6114         else {
6115                 ioarcb->write_ioadl_addr =
6116                         cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
6117                 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
6118         }
6119 }
6120
6121 /**
6122  * __ipr_erp_request_sense - Send request sense to a device
6123  * @ipr_cmd:    ipr command struct
6124  *
6125  * This function sends a request sense to a device as a result
6126  * of a check condition.
6127  *
6128  * Return value:
6129  *      nothing
6130  **/
6131 static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6132 {
6133         struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6134         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6135
6136         if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
6137                 __ipr_erp_done(ipr_cmd);
6138                 return;
6139         }
6140
6141         ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6142
6143         cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
6144         cmd_pkt->cdb[0] = REQUEST_SENSE;
6145         cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
6146         cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
6147         cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6148         cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
6149
6150         ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
6151                        SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
6152
6153         ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
6154                    IPR_REQUEST_SENSE_TIMEOUT * 2);
6155 }
6156
6157 /**
6158  * ipr_erp_request_sense - Send request sense to a device
6159  * @ipr_cmd:    ipr command struct
6160  *
6161  * This function sends a request sense to a device as a result
6162  * of a check condition.
6163  *
6164  * Return value:
6165  *      nothing
6166  **/
6167 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
6168 {
6169         struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
6170         unsigned long hrrq_flags;
6171
6172         spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
6173         __ipr_erp_request_sense(ipr_cmd);
6174         spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
6175 }
6176
6177 /**
6178  * ipr_erp_cancel_all - Send cancel all to a device
6179  * @ipr_cmd:    ipr command struct
6180  *
6181  * This function sends a cancel all to a device to clear the
6182  * queue. If we are running TCQ on the device, QERR is set to 1,
6183  * which means all outstanding ops have been dropped on the floor.
6184  * Cancel all will return them to us.
6185  *
6186  * Return value:
6187  *      nothing
6188  **/
6189 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
6190 {
6191         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6192         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6193         struct ipr_cmd_pkt *cmd_pkt;
6194
6195         res->in_erp = 1;
6196
6197         ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
6198
6199         if (!scsi_cmd->device->simple_tags) {
6200                 __ipr_erp_request_sense(ipr_cmd);
6201                 return;
6202         }
6203
6204         cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
6205         cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
6206         cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
6207
6208         ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
6209                    IPR_CANCEL_ALL_TIMEOUT);
6210 }
6211
6212 /**
6213  * ipr_dump_ioasa - Dump contents of IOASA
6214  * @ioa_cfg:    ioa config struct
6215  * @ipr_cmd:    ipr command struct
6216  * @res:                resource entry struct
6217  *
6218  * This function is invoked by the interrupt handler when ops
6219  * fail. It will log the IOASA if appropriate. Only called
6220  * for GPDD ops.
6221  *
6222  * Return value:
6223  *      none
6224  **/
6225 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
6226                            struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
6227 {
6228         int i;
6229         u16 data_len;
6230         u32 ioasc, fd_ioasc;
6231         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6232         __be32 *ioasa_data = (__be32 *)ioasa;
6233         int error_index;
6234
6235         ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
6236         fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
6237
6238         if (0 == ioasc)
6239                 return;
6240
6241         if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
6242                 return;
6243
6244         if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
6245                 error_index = ipr_get_error(fd_ioasc);
6246         else
6247                 error_index = ipr_get_error(ioasc);
6248
6249         if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
6250                 /* Don't log an error if the IOA already logged one */
6251                 if (ioasa->hdr.ilid != 0)
6252                         return;
6253
6254                 if (!ipr_is_gscsi(res))
6255                         return;
6256
6257                 if (ipr_error_table[error_index].log_ioasa == 0)
6258                         return;
6259         }
6260
6261         ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
6262
6263         data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
6264         if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
6265                 data_len = sizeof(struct ipr_ioasa64);
6266         else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
6267                 data_len = sizeof(struct ipr_ioasa);
6268
6269         ipr_err("IOASA Dump:\n");
6270
6271         for (i = 0; i < data_len / 4; i += 4) {
6272                 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
6273                         be32_to_cpu(ioasa_data[i]),
6274                         be32_to_cpu(ioasa_data[i+1]),
6275                         be32_to_cpu(ioasa_data[i+2]),
6276                         be32_to_cpu(ioasa_data[i+3]));
6277         }
6278 }
6279
6280 /**
6281  * ipr_gen_sense - Generate SCSI sense data from an IOASA
6282  * @ioasa:              IOASA
6283  * @sense_buf:  sense data buffer
6284  *
6285  * Return value:
6286  *      none
6287  **/
6288 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
6289 {
6290         u32 failing_lba;
6291         u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
6292         struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
6293         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6294         u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
6295
6296         memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
6297
6298         if (ioasc >= IPR_FIRST_DRIVER_IOASC)
6299                 return;
6300
6301         ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
6302
6303         if (ipr_is_vset_device(res) &&
6304             ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
6305             ioasa->u.vset.failing_lba_hi != 0) {
6306                 sense_buf[0] = 0x72;
6307                 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
6308                 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
6309                 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
6310
6311                 sense_buf[7] = 12;
6312                 sense_buf[8] = 0;
6313                 sense_buf[9] = 0x0A;
6314                 sense_buf[10] = 0x80;
6315
6316                 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
6317
6318                 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
6319                 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
6320                 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
6321                 sense_buf[15] = failing_lba & 0x000000ff;
6322
6323                 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6324
6325                 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
6326                 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
6327                 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
6328                 sense_buf[19] = failing_lba & 0x000000ff;
6329         } else {
6330                 sense_buf[0] = 0x70;
6331                 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
6332                 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
6333                 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
6334
6335                 /* Illegal request */
6336                 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
6337                     (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
6338                         sense_buf[7] = 10;      /* additional length */
6339
6340                         /* IOARCB was in error */
6341                         if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
6342                                 sense_buf[15] = 0xC0;
6343                         else    /* Parameter data was invalid */
6344                                 sense_buf[15] = 0x80;
6345
6346                         sense_buf[16] =
6347                             ((IPR_FIELD_POINTER_MASK &
6348                               be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
6349                         sense_buf[17] =
6350                             (IPR_FIELD_POINTER_MASK &
6351                              be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
6352                 } else {
6353                         if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
6354                                 if (ipr_is_vset_device(res))
6355                                         failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
6356                                 else
6357                                         failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
6358
6359                                 sense_buf[0] |= 0x80;   /* Or in the Valid bit */
6360                                 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
6361                                 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
6362                                 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
6363                                 sense_buf[6] = failing_lba & 0x000000ff;
6364                         }
6365
6366                         sense_buf[7] = 6;       /* additional length */
6367                 }
6368         }
6369 }
6370
6371 /**
6372  * ipr_get_autosense - Copy autosense data to sense buffer
6373  * @ipr_cmd:    ipr command struct
6374  *
6375  * This function copies the autosense buffer to the buffer
6376  * in the scsi_cmd, if there is autosense available.
6377  *
6378  * Return value:
6379  *      1 if autosense was available / 0 if not
6380  **/
6381 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
6382 {
6383         struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
6384         struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
6385
6386         if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
6387                 return 0;
6388
6389         if (ipr_cmd->ioa_cfg->sis64)
6390                 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
6391                        min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
6392                            SCSI_SENSE_BUFFERSIZE));
6393         else
6394                 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
6395                        min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
6396                            SCSI_SENSE_BUFFERSIZE));
6397         return 1;
6398 }
6399
6400 /**
6401  * ipr_erp_start - Process an error response for a SCSI op
6402  * @ioa_cfg:    ioa config struct
6403  * @ipr_cmd:    ipr command struct
6404  *
6405  * This function determines whether or not to initiate ERP
6406  * on the affected device.
6407  *
6408  * Return value:
6409  *      nothing
6410  **/
6411 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
6412                               struct ipr_cmnd *ipr_cmd)
6413 {
6414         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6415         struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
6416         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6417         u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
6418
6419         if (!res) {
6420                 __ipr_scsi_eh_done(ipr_cmd);
6421                 return;
6422         }
6423
6424         if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
6425                 ipr_gen_sense(ipr_cmd);
6426
6427         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6428
6429         switch (masked_ioasc) {
6430         case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
6431                 if (ipr_is_naca_model(res))
6432                         scsi_cmd->result |= (DID_ABORT << 16);
6433                 else
6434                         scsi_cmd->result |= (DID_IMM_RETRY << 16);
6435                 break;
6436         case IPR_IOASC_IR_RESOURCE_HANDLE:
6437         case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
6438                 scsi_cmd->result |= (DID_NO_CONNECT << 16);
6439                 break;
6440         case IPR_IOASC_HW_SEL_TIMEOUT:
6441                 scsi_cmd->result |= (DID_NO_CONNECT << 16);
6442                 if (!ipr_is_naca_model(res))
6443                         res->needs_sync_complete = 1;
6444                 break;
6445         case IPR_IOASC_SYNC_REQUIRED:
6446                 if (!res->in_erp)
6447                         res->needs_sync_complete = 1;
6448                 scsi_cmd->result |= (DID_IMM_RETRY << 16);
6449                 break;
6450         case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
6451         case IPR_IOASA_IR_DUAL_IOA_DISABLED:
6452                 /*
6453                  * exception: do not set DID_PASSTHROUGH on CHECK CONDITION
6454                  * so SCSI mid-layer and upper layers handle it accordingly.
6455                  */
6456                 if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION)
6457                         scsi_cmd->result |= (DID_PASSTHROUGH << 16);
6458                 break;
6459         case IPR_IOASC_BUS_WAS_RESET:
6460         case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
6461                 /*
6462                  * Report the bus reset and ask for a retry. The device
6463                  * will give CC/UA the next command.
6464                  */
6465                 if (!res->resetting_device)
6466                         scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
6467                 scsi_cmd->result |= (DID_ERROR << 16);
6468                 if (!ipr_is_naca_model(res))
6469                         res->needs_sync_complete = 1;
6470                 break;
6471         case IPR_IOASC_HW_DEV_BUS_STATUS:
6472                 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
6473                 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
6474                         if (!ipr_get_autosense(ipr_cmd)) {
6475                                 if (!ipr_is_naca_model(res)) {
6476                                         ipr_erp_cancel_all(ipr_cmd);
6477                                         return;
6478                                 }
6479                         }
6480                 }
6481                 if (!ipr_is_naca_model(res))
6482                         res->needs_sync_complete = 1;
6483                 break;
6484         case IPR_IOASC_NR_INIT_CMD_REQUIRED:
6485                 break;
6486         case IPR_IOASC_IR_NON_OPTIMIZED:
6487                 if (res->raw_mode) {
6488                         res->raw_mode = 0;
6489                         scsi_cmd->result |= (DID_IMM_RETRY << 16);
6490                 } else
6491                         scsi_cmd->result |= (DID_ERROR << 16);
6492                 break;
6493         default:
6494                 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6495                         scsi_cmd->result |= (DID_ERROR << 16);
6496                 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
6497                         res->needs_sync_complete = 1;
6498                 break;
6499         }
6500
6501         scsi_dma_unmap(ipr_cmd->scsi_cmd);
6502         scsi_cmd->scsi_done(scsi_cmd);
6503         if (ipr_cmd->eh_comp)
6504                 complete(ipr_cmd->eh_comp);
6505         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6506 }
6507
6508 /**
6509  * ipr_scsi_done - mid-layer done function
6510  * @ipr_cmd:    ipr command struct
6511  *
6512  * This function is invoked by the interrupt handler for
6513  * ops generated by the SCSI mid-layer
6514  *
6515  * Return value:
6516  *      none
6517  **/
6518 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
6519 {
6520         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6521         struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
6522         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6523         unsigned long lock_flags;
6524
6525         scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
6526
6527         if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
6528                 scsi_dma_unmap(scsi_cmd);
6529
6530                 spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags);
6531                 scsi_cmd->scsi_done(scsi_cmd);
6532                 if (ipr_cmd->eh_comp)
6533                         complete(ipr_cmd->eh_comp);
6534                 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6535                 spin_unlock_irqrestore(ipr_cmd->hrrq->lock, lock_flags);
6536         } else {
6537                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6538                 spin_lock(&ipr_cmd->hrrq->_lock);
6539                 ipr_erp_start(ioa_cfg, ipr_cmd);
6540                 spin_unlock(&ipr_cmd->hrrq->_lock);
6541                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6542         }
6543 }
6544
6545 /**
6546  * ipr_queuecommand - Queue a mid-layer request
6547  * @shost:              scsi host struct
6548  * @scsi_cmd:   scsi command struct
6549  *
6550  * This function queues a request generated by the mid-layer.
6551  *
6552  * Return value:
6553  *      0 on success
6554  *      SCSI_MLQUEUE_DEVICE_BUSY if device is busy
6555  *      SCSI_MLQUEUE_HOST_BUSY if host is busy
6556  **/
6557 static int ipr_queuecommand(struct Scsi_Host *shost,
6558                             struct scsi_cmnd *scsi_cmd)
6559 {
6560         struct ipr_ioa_cfg *ioa_cfg;
6561         struct ipr_resource_entry *res;
6562         struct ipr_ioarcb *ioarcb;
6563         struct ipr_cmnd *ipr_cmd;
6564         unsigned long hrrq_flags, lock_flags;
6565         int rc;
6566         struct ipr_hrr_queue *hrrq;
6567         int hrrq_id;
6568
6569         ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
6570
6571         scsi_cmd->result = (DID_OK << 16);
6572         res = scsi_cmd->device->hostdata;
6573
6574         if (ipr_is_gata(res) && res->sata_port) {
6575                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6576                 rc = ata_sas_queuecmd(scsi_cmd, res->sata_port->ap);
6577                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6578                 return rc;
6579         }
6580
6581         hrrq_id = ipr_get_hrrq_index(ioa_cfg);
6582         hrrq = &ioa_cfg->hrrq[hrrq_id];
6583
6584         spin_lock_irqsave(hrrq->lock, hrrq_flags);
6585         /*
6586          * We are currently blocking all devices due to a host reset
6587          * We have told the host to stop giving us new requests, but
6588          * ERP ops don't count. FIXME
6589          */
6590         if (unlikely(!hrrq->allow_cmds && !hrrq->ioa_is_dead && !hrrq->removing_ioa)) {
6591                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6592                 return SCSI_MLQUEUE_HOST_BUSY;
6593         }
6594
6595         /*
6596          * FIXME - Create scsi_set_host_offline interface
6597          *  and the ioa_is_dead check can be removed
6598          */
6599         if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) {
6600                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6601                 goto err_nodev;
6602         }
6603
6604         ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
6605         if (ipr_cmd == NULL) {
6606                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6607                 return SCSI_MLQUEUE_HOST_BUSY;
6608         }
6609         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6610
6611         ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done);
6612         ioarcb = &ipr_cmd->ioarcb;
6613
6614         memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
6615         ipr_cmd->scsi_cmd = scsi_cmd;
6616         ipr_cmd->done = ipr_scsi_eh_done;
6617
6618         if (ipr_is_gscsi(res)) {
6619                 if (scsi_cmd->underflow == 0)
6620                         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6621
6622                 if (res->reset_occurred) {
6623                         res->reset_occurred = 0;
6624                         ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
6625                 }
6626         }
6627
6628         if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
6629                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
6630
6631                 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
6632                 if (scsi_cmd->flags & SCMD_TAGGED)
6633                         ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK;
6634                 else
6635                         ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
6636         }
6637
6638         if (scsi_cmd->cmnd[0] >= 0xC0 &&
6639             (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE)) {
6640                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
6641         }
6642         if (res->raw_mode && ipr_is_af_dasd_device(res)) {
6643                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE;
6644
6645                 if (scsi_cmd->underflow == 0)
6646                         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
6647         }
6648
6649         if (ioa_cfg->sis64)
6650                 rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
6651         else
6652                 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
6653
6654         spin_lock_irqsave(hrrq->lock, hrrq_flags);
6655         if (unlikely(rc || (!hrrq->allow_cmds && !hrrq->ioa_is_dead))) {
6656                 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6657                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6658                 if (!rc)
6659                         scsi_dma_unmap(scsi_cmd);
6660                 return SCSI_MLQUEUE_HOST_BUSY;
6661         }
6662
6663         if (unlikely(hrrq->ioa_is_dead)) {
6664                 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
6665                 spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6666                 scsi_dma_unmap(scsi_cmd);
6667                 goto err_nodev;
6668         }
6669
6670         ioarcb->res_handle = res->res_handle;
6671         if (res->needs_sync_complete) {
6672                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
6673                 res->needs_sync_complete = 0;
6674         }
6675         list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_pending_q);
6676         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
6677         ipr_send_command(ipr_cmd);
6678         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6679         return 0;
6680
6681 err_nodev:
6682         spin_lock_irqsave(hrrq->lock, hrrq_flags);
6683         memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
6684         scsi_cmd->result = (DID_NO_CONNECT << 16);
6685         scsi_cmd->scsi_done(scsi_cmd);
6686         spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
6687         return 0;
6688 }
6689
6690 /**
6691  * ipr_ioctl - IOCTL handler
6692  * @sdev:       scsi device struct
6693  * @cmd:        IOCTL cmd
6694  * @arg:        IOCTL arg
6695  *
6696  * Return value:
6697  *      0 on success / other on failure
6698  **/
6699 static int ipr_ioctl(struct scsi_device *sdev, unsigned int cmd,
6700                      void __user *arg)
6701 {
6702         struct ipr_resource_entry *res;
6703
6704         res = (struct ipr_resource_entry *)sdev->hostdata;
6705         if (res && ipr_is_gata(res)) {
6706                 if (cmd == HDIO_GET_IDENTITY)
6707                         return -ENOTTY;
6708                 return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
6709         }
6710
6711         return -EINVAL;
6712 }
6713
6714 /**
6715  * ipr_info - Get information about the card/driver
6716  * @scsi_host:  scsi host struct
6717  *
6718  * Return value:
6719  *      pointer to buffer with description string
6720  **/
6721 static const char *ipr_ioa_info(struct Scsi_Host *host)
6722 {
6723         static char buffer[512];
6724         struct ipr_ioa_cfg *ioa_cfg;
6725         unsigned long lock_flags = 0;
6726
6727         ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
6728
6729         spin_lock_irqsave(host->host_lock, lock_flags);
6730         sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
6731         spin_unlock_irqrestore(host->host_lock, lock_flags);
6732
6733         return buffer;
6734 }
6735
6736 static struct scsi_host_template driver_template = {
6737         .module = THIS_MODULE,
6738         .name = "IPR",
6739         .info = ipr_ioa_info,
6740         .ioctl = ipr_ioctl,
6741         .queuecommand = ipr_queuecommand,
6742         .eh_abort_handler = ipr_eh_abort,
6743         .eh_device_reset_handler = ipr_eh_dev_reset,
6744         .eh_host_reset_handler = ipr_eh_host_reset,
6745         .slave_alloc = ipr_slave_alloc,
6746         .slave_configure = ipr_slave_configure,
6747         .slave_destroy = ipr_slave_destroy,
6748         .scan_finished = ipr_scan_finished,
6749         .target_alloc = ipr_target_alloc,
6750         .target_destroy = ipr_target_destroy,
6751         .change_queue_depth = ipr_change_queue_depth,
6752         .bios_param = ipr_biosparam,
6753         .can_queue = IPR_MAX_COMMANDS,
6754         .this_id = -1,
6755         .sg_tablesize = IPR_MAX_SGLIST,
6756         .max_sectors = IPR_IOA_MAX_SECTORS,
6757         .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
6758         .shost_attrs = ipr_ioa_attrs,
6759         .sdev_attrs = ipr_dev_attrs,
6760         .proc_name = IPR_NAME,
6761 };
6762
6763 /**
6764  * ipr_ata_phy_reset - libata phy_reset handler
6765  * @ap:         ata port to reset
6766  *
6767  **/
6768 static void ipr_ata_phy_reset(struct ata_port *ap)
6769 {
6770         unsigned long flags;
6771         struct ipr_sata_port *sata_port = ap->private_data;
6772         struct ipr_resource_entry *res = sata_port->res;
6773         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6774         int rc;
6775
6776         ENTER;
6777         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6778         while (ioa_cfg->in_reset_reload) {
6779                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6780                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6781                 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6782         }
6783
6784         if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds)
6785                 goto out_unlock;
6786
6787         rc = ipr_device_reset(ioa_cfg, res);
6788
6789         if (rc) {
6790                 ap->link.device[0].class = ATA_DEV_NONE;
6791                 goto out_unlock;
6792         }
6793
6794         ap->link.device[0].class = res->ata_class;
6795         if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
6796                 ap->link.device[0].class = ATA_DEV_NONE;
6797
6798 out_unlock:
6799         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6800         LEAVE;
6801 }
6802
6803 /**
6804  * ipr_ata_post_internal - Cleanup after an internal command
6805  * @qc: ATA queued command
6806  *
6807  * Return value:
6808  *      none
6809  **/
6810 static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
6811 {
6812         struct ipr_sata_port *sata_port = qc->ap->private_data;
6813         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
6814         struct ipr_cmnd *ipr_cmd;
6815         struct ipr_hrr_queue *hrrq;
6816         unsigned long flags;
6817
6818         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6819         while (ioa_cfg->in_reset_reload) {
6820                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6821                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6822                 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6823         }
6824
6825         for_each_hrrq(hrrq, ioa_cfg) {
6826                 spin_lock(&hrrq->_lock);
6827                 list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
6828                         if (ipr_cmd->qc == qc) {
6829                                 ipr_device_reset(ioa_cfg, sata_port->res);
6830                                 break;
6831                         }
6832                 }
6833                 spin_unlock(&hrrq->_lock);
6834         }
6835         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6836 }
6837
6838 /**
6839  * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
6840  * @regs:       destination
6841  * @tf: source ATA taskfile
6842  *
6843  * Return value:
6844  *      none
6845  **/
6846 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
6847                              struct ata_taskfile *tf)
6848 {
6849         regs->feature = tf->feature;
6850         regs->nsect = tf->nsect;
6851         regs->lbal = tf->lbal;
6852         regs->lbam = tf->lbam;
6853         regs->lbah = tf->lbah;
6854         regs->device = tf->device;
6855         regs->command = tf->command;
6856         regs->hob_feature = tf->hob_feature;
6857         regs->hob_nsect = tf->hob_nsect;
6858         regs->hob_lbal = tf->hob_lbal;
6859         regs->hob_lbam = tf->hob_lbam;
6860         regs->hob_lbah = tf->hob_lbah;
6861         regs->ctl = tf->ctl;
6862 }
6863
6864 /**
6865  * ipr_sata_done - done function for SATA commands
6866  * @ipr_cmd:    ipr command struct
6867  *
6868  * This function is invoked by the interrupt handler for
6869  * ops generated by the SCSI mid-layer to SATA devices
6870  *
6871  * Return value:
6872  *      none
6873  **/
6874 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
6875 {
6876         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6877         struct ata_queued_cmd *qc = ipr_cmd->qc;
6878         struct ipr_sata_port *sata_port = qc->ap->private_data;
6879         struct ipr_resource_entry *res = sata_port->res;
6880         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
6881
6882         spin_lock(&ipr_cmd->hrrq->_lock);
6883         if (ipr_cmd->ioa_cfg->sis64)
6884                 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
6885                        sizeof(struct ipr_ioasa_gata));
6886         else
6887                 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
6888                        sizeof(struct ipr_ioasa_gata));
6889         ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
6890
6891         if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
6892                 scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
6893
6894         if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
6895                 qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
6896         else
6897                 qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
6898         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
6899         spin_unlock(&ipr_cmd->hrrq->_lock);
6900         ata_qc_complete(qc);
6901 }
6902
6903 /**
6904  * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
6905  * @ipr_cmd:    ipr command struct
6906  * @qc:         ATA queued command
6907  *
6908  **/
6909 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
6910                                   struct ata_queued_cmd *qc)
6911 {
6912         u32 ioadl_flags = 0;
6913         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6914         struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64;
6915         struct ipr_ioadl64_desc *last_ioadl64 = NULL;
6916         int len = qc->nbytes;
6917         struct scatterlist *sg;
6918         unsigned int si;
6919         dma_addr_t dma_addr = ipr_cmd->dma_addr;
6920
6921         if (len == 0)
6922                 return;
6923
6924         if (qc->dma_dir == DMA_TO_DEVICE) {
6925                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6926                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6927         } else if (qc->dma_dir == DMA_FROM_DEVICE)
6928                 ioadl_flags = IPR_IOADL_FLAGS_READ;
6929
6930         ioarcb->data_transfer_length = cpu_to_be32(len);
6931         ioarcb->ioadl_len =
6932                 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
6933         ioarcb->u.sis64_addr_data.data_ioadl_addr =
6934                 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64));
6935
6936         for_each_sg(qc->sg, sg, qc->n_elem, si) {
6937                 ioadl64->flags = cpu_to_be32(ioadl_flags);
6938                 ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
6939                 ioadl64->address = cpu_to_be64(sg_dma_address(sg));
6940
6941                 last_ioadl64 = ioadl64;
6942                 ioadl64++;
6943         }
6944
6945         if (likely(last_ioadl64))
6946                 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6947 }
6948
6949 /**
6950  * ipr_build_ata_ioadl - Build an ATA scatter/gather list
6951  * @ipr_cmd:    ipr command struct
6952  * @qc:         ATA queued command
6953  *
6954  **/
6955 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
6956                                 struct ata_queued_cmd *qc)
6957 {
6958         u32 ioadl_flags = 0;
6959         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6960         struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
6961         struct ipr_ioadl_desc *last_ioadl = NULL;
6962         int len = qc->nbytes;
6963         struct scatterlist *sg;
6964         unsigned int si;
6965
6966         if (len == 0)
6967                 return;
6968
6969         if (qc->dma_dir == DMA_TO_DEVICE) {
6970                 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
6971                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
6972                 ioarcb->data_transfer_length = cpu_to_be32(len);
6973                 ioarcb->ioadl_len =
6974                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6975         } else if (qc->dma_dir == DMA_FROM_DEVICE) {
6976                 ioadl_flags = IPR_IOADL_FLAGS_READ;
6977                 ioarcb->read_data_transfer_length = cpu_to_be32(len);
6978                 ioarcb->read_ioadl_len =
6979                         cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
6980         }
6981
6982         for_each_sg(qc->sg, sg, qc->n_elem, si) {
6983                 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
6984                 ioadl->address = cpu_to_be32(sg_dma_address(sg));
6985
6986                 last_ioadl = ioadl;
6987                 ioadl++;
6988         }
6989
6990         if (likely(last_ioadl))
6991                 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
6992 }
6993
6994 /**
6995  * ipr_qc_defer - Get a free ipr_cmd
6996  * @qc: queued command
6997  *
6998  * Return value:
6999  *      0 if success
7000  **/
7001 static int ipr_qc_defer(struct ata_queued_cmd *qc)
7002 {
7003         struct ata_port *ap = qc->ap;
7004         struct ipr_sata_port *sata_port = ap->private_data;
7005         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
7006         struct ipr_cmnd *ipr_cmd;
7007         struct ipr_hrr_queue *hrrq;
7008         int hrrq_id;
7009
7010         hrrq_id = ipr_get_hrrq_index(ioa_cfg);
7011         hrrq = &ioa_cfg->hrrq[hrrq_id];
7012
7013         qc->lldd_task = NULL;
7014         spin_lock(&hrrq->_lock);
7015         if (unlikely(hrrq->ioa_is_dead)) {
7016                 spin_unlock(&hrrq->_lock);
7017                 return 0;
7018         }
7019
7020         if (unlikely(!hrrq->allow_cmds)) {
7021                 spin_unlock(&hrrq->_lock);
7022                 return ATA_DEFER_LINK;
7023         }
7024
7025         ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
7026         if (ipr_cmd == NULL) {
7027                 spin_unlock(&hrrq->_lock);
7028                 return ATA_DEFER_LINK;
7029         }
7030
7031         qc->lldd_task = ipr_cmd;
7032         spin_unlock(&hrrq->_lock);
7033         return 0;
7034 }
7035
7036 /**
7037  * ipr_qc_issue - Issue a SATA qc to a device
7038  * @qc: queued command
7039  *
7040  * Return value:
7041  *      0 if success
7042  **/
7043 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
7044 {
7045         struct ata_port *ap = qc->ap;
7046         struct ipr_sata_port *sata_port = ap->private_data;
7047         struct ipr_resource_entry *res = sata_port->res;
7048         struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
7049         struct ipr_cmnd *ipr_cmd;
7050         struct ipr_ioarcb *ioarcb;
7051         struct ipr_ioarcb_ata_regs *regs;
7052
7053         if (qc->lldd_task == NULL)
7054                 ipr_qc_defer(qc);
7055
7056         ipr_cmd = qc->lldd_task;
7057         if (ipr_cmd == NULL)
7058                 return AC_ERR_SYSTEM;
7059
7060         qc->lldd_task = NULL;
7061         spin_lock(&ipr_cmd->hrrq->_lock);
7062         if (unlikely(!ipr_cmd->hrrq->allow_cmds ||
7063                         ipr_cmd->hrrq->ioa_is_dead)) {
7064                 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7065                 spin_unlock(&ipr_cmd->hrrq->_lock);
7066                 return AC_ERR_SYSTEM;
7067         }
7068
7069         ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
7070         ioarcb = &ipr_cmd->ioarcb;
7071
7072         if (ioa_cfg->sis64) {
7073                 regs = &ipr_cmd->i.ata_ioadl.regs;
7074                 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
7075         } else
7076                 regs = &ioarcb->u.add_data.u.regs;
7077
7078         memset(regs, 0, sizeof(*regs));
7079         ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
7080
7081         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
7082         ipr_cmd->qc = qc;
7083         ipr_cmd->done = ipr_sata_done;
7084         ipr_cmd->ioarcb.res_handle = res->res_handle;
7085         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
7086         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
7087         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
7088         ipr_cmd->dma_use_sg = qc->n_elem;
7089
7090         if (ioa_cfg->sis64)
7091                 ipr_build_ata_ioadl64(ipr_cmd, qc);
7092         else
7093                 ipr_build_ata_ioadl(ipr_cmd, qc);
7094
7095         regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
7096         ipr_copy_sata_tf(regs, &qc->tf);
7097         memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
7098         ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
7099
7100         switch (qc->tf.protocol) {
7101         case ATA_PROT_NODATA:
7102         case ATA_PROT_PIO:
7103                 break;
7104
7105         case ATA_PROT_DMA:
7106                 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7107                 break;
7108
7109         case ATAPI_PROT_PIO:
7110         case ATAPI_PROT_NODATA:
7111                 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7112                 break;
7113
7114         case ATAPI_PROT_DMA:
7115                 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
7116                 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
7117                 break;
7118
7119         default:
7120                 WARN_ON(1);
7121                 spin_unlock(&ipr_cmd->hrrq->_lock);
7122                 return AC_ERR_INVALID;
7123         }
7124
7125         ipr_send_command(ipr_cmd);
7126         spin_unlock(&ipr_cmd->hrrq->_lock);
7127
7128         return 0;
7129 }
7130
7131 /**
7132  * ipr_qc_fill_rtf - Read result TF
7133  * @qc: ATA queued command
7134  *
7135  * Return value:
7136  *      true
7137  **/
7138 static bool ipr_qc_fill_rtf(struct ata_queued_cmd *qc)
7139 {
7140         struct ipr_sata_port *sata_port = qc->ap->private_data;
7141         struct ipr_ioasa_gata *g = &sata_port->ioasa;
7142         struct ata_taskfile *tf = &qc->result_tf;
7143
7144         tf->feature = g->error;
7145         tf->nsect = g->nsect;
7146         tf->lbal = g->lbal;
7147         tf->lbam = g->lbam;
7148         tf->lbah = g->lbah;
7149         tf->device = g->device;
7150         tf->command = g->status;
7151         tf->hob_nsect = g->hob_nsect;
7152         tf->hob_lbal = g->hob_lbal;
7153         tf->hob_lbam = g->hob_lbam;
7154         tf->hob_lbah = g->hob_lbah;
7155
7156         return true;
7157 }
7158
7159 static struct ata_port_operations ipr_sata_ops = {
7160         .phy_reset = ipr_ata_phy_reset,
7161         .hardreset = ipr_sata_reset,
7162         .post_internal_cmd = ipr_ata_post_internal,
7163         .qc_prep = ata_noop_qc_prep,
7164         .qc_defer = ipr_qc_defer,
7165         .qc_issue = ipr_qc_issue,
7166         .qc_fill_rtf = ipr_qc_fill_rtf,
7167         .port_start = ata_sas_port_start,
7168         .port_stop = ata_sas_port_stop
7169 };
7170
7171 static struct ata_port_info sata_port_info = {
7172         .flags          = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
7173                           ATA_FLAG_SAS_HOST,
7174         .pio_mask       = ATA_PIO4_ONLY,
7175         .mwdma_mask     = ATA_MWDMA2,
7176         .udma_mask      = ATA_UDMA6,
7177         .port_ops       = &ipr_sata_ops
7178 };
7179
7180 #ifdef CONFIG_PPC_PSERIES
7181 static const u16 ipr_blocked_processors[] = {
7182         PVR_NORTHSTAR,
7183         PVR_PULSAR,
7184         PVR_POWER4,
7185         PVR_ICESTAR,
7186         PVR_SSTAR,
7187         PVR_POWER4p,
7188         PVR_630,
7189         PVR_630p
7190 };
7191
7192 /**
7193  * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
7194  * @ioa_cfg:    ioa cfg struct
7195  *
7196  * Adapters that use Gemstone revision < 3.1 do not work reliably on
7197  * certain pSeries hardware. This function determines if the given
7198  * adapter is in one of these confgurations or not.
7199  *
7200  * Return value:
7201  *      1 if adapter is not supported / 0 if adapter is supported
7202  **/
7203 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
7204 {
7205         int i;
7206
7207         if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
7208                 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
7209                         if (pvr_version_is(ipr_blocked_processors[i]))
7210                                 return 1;
7211                 }
7212         }
7213         return 0;
7214 }
7215 #else
7216 #define ipr_invalid_adapter(ioa_cfg) 0
7217 #endif
7218
7219 /**
7220  * ipr_ioa_bringdown_done - IOA bring down completion.
7221  * @ipr_cmd:    ipr command struct
7222  *
7223  * This function processes the completion of an adapter bring down.
7224  * It wakes any reset sleepers.
7225  *
7226  * Return value:
7227  *      IPR_RC_JOB_RETURN
7228  **/
7229 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
7230 {
7231         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7232         int i;
7233
7234         ENTER;
7235         if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
7236                 ipr_trace;
7237                 ioa_cfg->scsi_unblock = 1;
7238                 schedule_work(&ioa_cfg->work_q);
7239         }
7240
7241         ioa_cfg->in_reset_reload = 0;
7242         ioa_cfg->reset_retries = 0;
7243         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
7244                 spin_lock(&ioa_cfg->hrrq[i]._lock);
7245                 ioa_cfg->hrrq[i].ioa_is_dead = 1;
7246                 spin_unlock(&ioa_cfg->hrrq[i]._lock);
7247         }
7248         wmb();
7249
7250         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7251         wake_up_all(&ioa_cfg->reset_wait_q);
7252         LEAVE;
7253
7254         return IPR_RC_JOB_RETURN;
7255 }
7256
7257 /**
7258  * ipr_ioa_reset_done - IOA reset completion.
7259  * @ipr_cmd:    ipr command struct
7260  *
7261  * This function processes the completion of an adapter reset.
7262  * It schedules any necessary mid-layer add/removes and
7263  * wakes any reset sleepers.
7264  *
7265  * Return value:
7266  *      IPR_RC_JOB_RETURN
7267  **/
7268 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
7269 {
7270         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7271         struct ipr_resource_entry *res;
7272         int j;
7273
7274         ENTER;
7275         ioa_cfg->in_reset_reload = 0;
7276         for (j = 0; j < ioa_cfg->hrrq_num; j++) {
7277                 spin_lock(&ioa_cfg->hrrq[j]._lock);
7278                 ioa_cfg->hrrq[j].allow_cmds = 1;
7279                 spin_unlock(&ioa_cfg->hrrq[j]._lock);
7280         }
7281         wmb();
7282         ioa_cfg->reset_cmd = NULL;
7283         ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
7284
7285         list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
7286                 if (res->add_to_ml || res->del_from_ml) {
7287                         ipr_trace;
7288                         break;
7289                 }
7290         }
7291         schedule_work(&ioa_cfg->work_q);
7292
7293         for (j = 0; j < IPR_NUM_HCAMS; j++) {
7294                 list_del_init(&ioa_cfg->hostrcb[j]->queue);
7295                 if (j < IPR_NUM_LOG_HCAMS)
7296                         ipr_send_hcam(ioa_cfg,
7297                                 IPR_HCAM_CDB_OP_CODE_LOG_DATA,
7298                                 ioa_cfg->hostrcb[j]);
7299                 else
7300                         ipr_send_hcam(ioa_cfg,
7301                                 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
7302                                 ioa_cfg->hostrcb[j]);
7303         }
7304
7305         scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
7306         dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
7307
7308         ioa_cfg->reset_retries = 0;
7309         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7310         wake_up_all(&ioa_cfg->reset_wait_q);
7311
7312         ioa_cfg->scsi_unblock = 1;
7313         schedule_work(&ioa_cfg->work_q);
7314         LEAVE;
7315         return IPR_RC_JOB_RETURN;
7316 }
7317
7318 /**
7319  * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
7320  * @supported_dev:      supported device struct
7321  * @vpids:                      vendor product id struct
7322  *
7323  * Return value:
7324  *      none
7325  **/
7326 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
7327                                  struct ipr_std_inq_vpids *vpids)
7328 {
7329         memset(supported_dev, 0, sizeof(struct ipr_supported_device));
7330         memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
7331         supported_dev->num_records = 1;
7332         supported_dev->data_length =
7333                 cpu_to_be16(sizeof(struct ipr_supported_device));
7334         supported_dev->reserved = 0;
7335 }
7336
7337 /**
7338  * ipr_set_supported_devs - Send Set Supported Devices for a device
7339  * @ipr_cmd:    ipr command struct
7340  *
7341  * This function sends a Set Supported Devices to the adapter
7342  *
7343  * Return value:
7344  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7345  **/
7346 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
7347 {
7348         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7349         struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
7350         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7351         struct ipr_resource_entry *res = ipr_cmd->u.res;
7352
7353         ipr_cmd->job_step = ipr_ioa_reset_done;
7354
7355         list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
7356                 if (!ipr_is_scsi_disk(res))
7357                         continue;
7358
7359                 ipr_cmd->u.res = res;
7360                 ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
7361
7362                 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7363                 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7364                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7365
7366                 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
7367                 ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
7368                 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
7369                 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
7370
7371                 ipr_init_ioadl(ipr_cmd,
7372                                ioa_cfg->vpd_cbs_dma +
7373                                  offsetof(struct ipr_misc_cbs, supp_dev),
7374                                sizeof(struct ipr_supported_device),
7375                                IPR_IOADL_FLAGS_WRITE_LAST);
7376
7377                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7378                            IPR_SET_SUP_DEVICE_TIMEOUT);
7379
7380                 if (!ioa_cfg->sis64)
7381                         ipr_cmd->job_step = ipr_set_supported_devs;
7382                 LEAVE;
7383                 return IPR_RC_JOB_RETURN;
7384         }
7385
7386         LEAVE;
7387         return IPR_RC_JOB_CONTINUE;
7388 }
7389
7390 /**
7391  * ipr_get_mode_page - Locate specified mode page
7392  * @mode_pages: mode page buffer
7393  * @page_code:  page code to find
7394  * @len:                minimum required length for mode page
7395  *
7396  * Return value:
7397  *      pointer to mode page / NULL on failure
7398  **/
7399 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
7400                                u32 page_code, u32 len)
7401 {
7402         struct ipr_mode_page_hdr *mode_hdr;
7403         u32 page_length;
7404         u32 length;
7405
7406         if (!mode_pages || (mode_pages->hdr.length == 0))
7407                 return NULL;
7408
7409         length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
7410         mode_hdr = (struct ipr_mode_page_hdr *)
7411                 (mode_pages->data + mode_pages->hdr.block_desc_len);
7412
7413         while (length) {
7414                 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
7415                         if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
7416                                 return mode_hdr;
7417                         break;
7418                 } else {
7419                         page_length = (sizeof(struct ipr_mode_page_hdr) +
7420                                        mode_hdr->page_length);
7421                         length -= page_length;
7422                         mode_hdr = (struct ipr_mode_page_hdr *)
7423                                 ((unsigned long)mode_hdr + page_length);
7424                 }
7425         }
7426         return NULL;
7427 }
7428
7429 /**
7430  * ipr_check_term_power - Check for term power errors
7431  * @ioa_cfg:    ioa config struct
7432  * @mode_pages: IOAFP mode pages buffer
7433  *
7434  * Check the IOAFP's mode page 28 for term power errors
7435  *
7436  * Return value:
7437  *      nothing
7438  **/
7439 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
7440                                  struct ipr_mode_pages *mode_pages)
7441 {
7442         int i;
7443         int entry_length;
7444         struct ipr_dev_bus_entry *bus;
7445         struct ipr_mode_page28 *mode_page;
7446
7447         mode_page = ipr_get_mode_page(mode_pages, 0x28,
7448                                       sizeof(struct ipr_mode_page28));
7449
7450         entry_length = mode_page->entry_length;
7451
7452         bus = mode_page->bus;
7453
7454         for (i = 0; i < mode_page->num_entries; i++) {
7455                 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
7456                         dev_err(&ioa_cfg->pdev->dev,
7457                                 "Term power is absent on scsi bus %d\n",
7458                                 bus->res_addr.bus);
7459                 }
7460
7461                 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
7462         }
7463 }
7464
7465 /**
7466  * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
7467  * @ioa_cfg:    ioa config struct
7468  *
7469  * Looks through the config table checking for SES devices. If
7470  * the SES device is in the SES table indicating a maximum SCSI
7471  * bus speed, the speed is limited for the bus.
7472  *
7473  * Return value:
7474  *      none
7475  **/
7476 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
7477 {
7478         u32 max_xfer_rate;
7479         int i;
7480
7481         for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
7482                 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
7483                                                        ioa_cfg->bus_attr[i].bus_width);
7484
7485                 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
7486                         ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
7487         }
7488 }
7489
7490 /**
7491  * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
7492  * @ioa_cfg:    ioa config struct
7493  * @mode_pages: mode page 28 buffer
7494  *
7495  * Updates mode page 28 based on driver configuration
7496  *
7497  * Return value:
7498  *      none
7499  **/
7500 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
7501                                           struct ipr_mode_pages *mode_pages)
7502 {
7503         int i, entry_length;
7504         struct ipr_dev_bus_entry *bus;
7505         struct ipr_bus_attributes *bus_attr;
7506         struct ipr_mode_page28 *mode_page;
7507
7508         mode_page = ipr_get_mode_page(mode_pages, 0x28,
7509                                       sizeof(struct ipr_mode_page28));
7510
7511         entry_length = mode_page->entry_length;
7512
7513         /* Loop for each device bus entry */
7514         for (i = 0, bus = mode_page->bus;
7515              i < mode_page->num_entries;
7516              i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
7517                 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
7518                         dev_err(&ioa_cfg->pdev->dev,
7519                                 "Invalid resource address reported: 0x%08X\n",
7520                                 IPR_GET_PHYS_LOC(bus->res_addr));
7521                         continue;
7522                 }
7523
7524                 bus_attr = &ioa_cfg->bus_attr[i];
7525                 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
7526                 bus->bus_width = bus_attr->bus_width;
7527                 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
7528                 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
7529                 if (bus_attr->qas_enabled)
7530                         bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
7531                 else
7532                         bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
7533         }
7534 }
7535
7536 /**
7537  * ipr_build_mode_select - Build a mode select command
7538  * @ipr_cmd:    ipr command struct
7539  * @res_handle: resource handle to send command to
7540  * @parm:               Byte 2 of Mode Sense command
7541  * @dma_addr:   DMA buffer address
7542  * @xfer_len:   data transfer length
7543  *
7544  * Return value:
7545  *      none
7546  **/
7547 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
7548                                   __be32 res_handle, u8 parm,
7549                                   dma_addr_t dma_addr, u8 xfer_len)
7550 {
7551         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7552
7553         ioarcb->res_handle = res_handle;
7554         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7555         ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
7556         ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
7557         ioarcb->cmd_pkt.cdb[1] = parm;
7558         ioarcb->cmd_pkt.cdb[4] = xfer_len;
7559
7560         ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
7561 }
7562
7563 /**
7564  * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
7565  * @ipr_cmd:    ipr command struct
7566  *
7567  * This function sets up the SCSI bus attributes and sends
7568  * a Mode Select for Page 28 to activate them.
7569  *
7570  * Return value:
7571  *      IPR_RC_JOB_RETURN
7572  **/
7573 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
7574 {
7575         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7576         struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7577         int length;
7578
7579         ENTER;
7580         ipr_scsi_bus_speed_limit(ioa_cfg);
7581         ipr_check_term_power(ioa_cfg, mode_pages);
7582         ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
7583         length = mode_pages->hdr.length + 1;
7584         mode_pages->hdr.length = 0;
7585
7586         ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7587                               ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7588                               length);
7589
7590         ipr_cmd->job_step = ipr_set_supported_devs;
7591         ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7592                                     struct ipr_resource_entry, queue);
7593         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7594
7595         LEAVE;
7596         return IPR_RC_JOB_RETURN;
7597 }
7598
7599 /**
7600  * ipr_build_mode_sense - Builds a mode sense command
7601  * @ipr_cmd:    ipr command struct
7602  * @res:                resource entry struct
7603  * @parm:               Byte 2 of mode sense command
7604  * @dma_addr:   DMA address of mode sense buffer
7605  * @xfer_len:   Size of DMA buffer
7606  *
7607  * Return value:
7608  *      none
7609  **/
7610 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
7611                                  __be32 res_handle,
7612                                  u8 parm, dma_addr_t dma_addr, u8 xfer_len)
7613 {
7614         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7615
7616         ioarcb->res_handle = res_handle;
7617         ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
7618         ioarcb->cmd_pkt.cdb[2] = parm;
7619         ioarcb->cmd_pkt.cdb[4] = xfer_len;
7620         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7621
7622         ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
7623 }
7624
7625 /**
7626  * ipr_reset_cmd_failed - Handle failure of IOA reset command
7627  * @ipr_cmd:    ipr command struct
7628  *
7629  * This function handles the failure of an IOA bringup command.
7630  *
7631  * Return value:
7632  *      IPR_RC_JOB_RETURN
7633  **/
7634 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
7635 {
7636         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7637         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7638
7639         dev_err(&ioa_cfg->pdev->dev,
7640                 "0x%02X failed with IOASC: 0x%08X\n",
7641                 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
7642
7643         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
7644         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
7645         return IPR_RC_JOB_RETURN;
7646 }
7647
7648 /**
7649  * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
7650  * @ipr_cmd:    ipr command struct
7651  *
7652  * This function handles the failure of a Mode Sense to the IOAFP.
7653  * Some adapters do not handle all mode pages.
7654  *
7655  * Return value:
7656  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7657  **/
7658 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
7659 {
7660         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7661         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7662
7663         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7664                 ipr_cmd->job_step = ipr_set_supported_devs;
7665                 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
7666                                             struct ipr_resource_entry, queue);
7667                 return IPR_RC_JOB_CONTINUE;
7668         }
7669
7670         return ipr_reset_cmd_failed(ipr_cmd);
7671 }
7672
7673 /**
7674  * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
7675  * @ipr_cmd:    ipr command struct
7676  *
7677  * This function send a Page 28 mode sense to the IOA to
7678  * retrieve SCSI bus attributes.
7679  *
7680  * Return value:
7681  *      IPR_RC_JOB_RETURN
7682  **/
7683 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
7684 {
7685         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7686
7687         ENTER;
7688         ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7689                              0x28, ioa_cfg->vpd_cbs_dma +
7690                              offsetof(struct ipr_misc_cbs, mode_pages),
7691                              sizeof(struct ipr_mode_pages));
7692
7693         ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
7694         ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
7695
7696         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7697
7698         LEAVE;
7699         return IPR_RC_JOB_RETURN;
7700 }
7701
7702 /**
7703  * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
7704  * @ipr_cmd:    ipr command struct
7705  *
7706  * This function enables dual IOA RAID support if possible.
7707  *
7708  * Return value:
7709  *      IPR_RC_JOB_RETURN
7710  **/
7711 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
7712 {
7713         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7714         struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
7715         struct ipr_mode_page24 *mode_page;
7716         int length;
7717
7718         ENTER;
7719         mode_page = ipr_get_mode_page(mode_pages, 0x24,
7720                                       sizeof(struct ipr_mode_page24));
7721
7722         if (mode_page)
7723                 mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
7724
7725         length = mode_pages->hdr.length + 1;
7726         mode_pages->hdr.length = 0;
7727
7728         ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
7729                               ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
7730                               length);
7731
7732         ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7733         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7734
7735         LEAVE;
7736         return IPR_RC_JOB_RETURN;
7737 }
7738
7739 /**
7740  * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
7741  * @ipr_cmd:    ipr command struct
7742  *
7743  * This function handles the failure of a Mode Sense to the IOAFP.
7744  * Some adapters do not handle all mode pages.
7745  *
7746  * Return value:
7747  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
7748  **/
7749 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
7750 {
7751         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7752
7753         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
7754                 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7755                 return IPR_RC_JOB_CONTINUE;
7756         }
7757
7758         return ipr_reset_cmd_failed(ipr_cmd);
7759 }
7760
7761 /**
7762  * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
7763  * @ipr_cmd:    ipr command struct
7764  *
7765  * This function send a mode sense to the IOA to retrieve
7766  * the IOA Advanced Function Control mode page.
7767  *
7768  * Return value:
7769  *      IPR_RC_JOB_RETURN
7770  **/
7771 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
7772 {
7773         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7774
7775         ENTER;
7776         ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
7777                              0x24, ioa_cfg->vpd_cbs_dma +
7778                              offsetof(struct ipr_misc_cbs, mode_pages),
7779                              sizeof(struct ipr_mode_pages));
7780
7781         ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
7782         ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
7783
7784         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7785
7786         LEAVE;
7787         return IPR_RC_JOB_RETURN;
7788 }
7789
7790 /**
7791  * ipr_init_res_table - Initialize the resource table
7792  * @ipr_cmd:    ipr command struct
7793  *
7794  * This function looks through the existing resource table, comparing
7795  * it with the config table. This function will take care of old/new
7796  * devices and schedule adding/removing them from the mid-layer
7797  * as appropriate.
7798  *
7799  * Return value:
7800  *      IPR_RC_JOB_CONTINUE
7801  **/
7802 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
7803 {
7804         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7805         struct ipr_resource_entry *res, *temp;
7806         struct ipr_config_table_entry_wrapper cfgtew;
7807         int entries, found, flag, i;
7808         LIST_HEAD(old_res);
7809
7810         ENTER;
7811         if (ioa_cfg->sis64)
7812                 flag = ioa_cfg->u.cfg_table64->hdr64.flags;
7813         else
7814                 flag = ioa_cfg->u.cfg_table->hdr.flags;
7815
7816         if (flag & IPR_UCODE_DOWNLOAD_REQ)
7817                 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
7818
7819         list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
7820                 list_move_tail(&res->queue, &old_res);
7821
7822         if (ioa_cfg->sis64)
7823                 entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
7824         else
7825                 entries = ioa_cfg->u.cfg_table->hdr.num_entries;
7826
7827         for (i = 0; i < entries; i++) {
7828                 if (ioa_cfg->sis64)
7829                         cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
7830                 else
7831                         cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
7832                 found = 0;
7833
7834                 list_for_each_entry_safe(res, temp, &old_res, queue) {
7835                         if (ipr_is_same_device(res, &cfgtew)) {
7836                                 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7837                                 found = 1;
7838                                 break;
7839                         }
7840                 }
7841
7842                 if (!found) {
7843                         if (list_empty(&ioa_cfg->free_res_q)) {
7844                                 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
7845                                 break;
7846                         }
7847
7848                         found = 1;
7849                         res = list_entry(ioa_cfg->free_res_q.next,
7850                                          struct ipr_resource_entry, queue);
7851                         list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7852                         ipr_init_res_entry(res, &cfgtew);
7853                         res->add_to_ml = 1;
7854                 } else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res)))
7855                         res->sdev->allow_restart = 1;
7856
7857                 if (found)
7858                         ipr_update_res_entry(res, &cfgtew);
7859         }
7860
7861         list_for_each_entry_safe(res, temp, &old_res, queue) {
7862                 if (res->sdev) {
7863                         res->del_from_ml = 1;
7864                         res->res_handle = IPR_INVALID_RES_HANDLE;
7865                         list_move_tail(&res->queue, &ioa_cfg->used_res_q);
7866                 }
7867         }
7868
7869         list_for_each_entry_safe(res, temp, &old_res, queue) {
7870                 ipr_clear_res_target(res);
7871                 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
7872         }
7873
7874         if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
7875                 ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
7876         else
7877                 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
7878
7879         LEAVE;
7880         return IPR_RC_JOB_CONTINUE;
7881 }
7882
7883 /**
7884  * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
7885  * @ipr_cmd:    ipr command struct
7886  *
7887  * This function sends a Query IOA Configuration command
7888  * to the adapter to retrieve the IOA configuration table.
7889  *
7890  * Return value:
7891  *      IPR_RC_JOB_RETURN
7892  **/
7893 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
7894 {
7895         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7896         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7897         struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
7898         struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
7899
7900         ENTER;
7901         if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
7902                 ioa_cfg->dual_raid = 1;
7903         dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
7904                  ucode_vpd->major_release, ucode_vpd->card_type,
7905                  ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
7906         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7907         ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7908
7909         ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
7910         ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
7911         ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
7912         ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
7913
7914         ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
7915                        IPR_IOADL_FLAGS_READ_LAST);
7916
7917         ipr_cmd->job_step = ipr_init_res_table;
7918
7919         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
7920
7921         LEAVE;
7922         return IPR_RC_JOB_RETURN;
7923 }
7924
7925 static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd)
7926 {
7927         u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
7928
7929         if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT)
7930                 return IPR_RC_JOB_CONTINUE;
7931
7932         return ipr_reset_cmd_failed(ipr_cmd);
7933 }
7934
7935 static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd,
7936                                          __be32 res_handle, u8 sa_code)
7937 {
7938         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7939
7940         ioarcb->res_handle = res_handle;
7941         ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION;
7942         ioarcb->cmd_pkt.cdb[1] = sa_code;
7943         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
7944 }
7945
7946 /**
7947  * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
7948  * action
7949  *
7950  * Return value:
7951  *      none
7952  **/
7953 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd)
7954 {
7955         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7956         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
7957         struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
7958
7959         ENTER;
7960
7961         ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
7962
7963         if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) {
7964                 ipr_build_ioa_service_action(ipr_cmd,
7965                                              cpu_to_be32(IPR_IOA_RES_HANDLE),
7966                                              IPR_IOA_SA_CHANGE_CACHE_PARAMS);
7967
7968                 ioarcb->cmd_pkt.cdb[2] = 0x40;
7969
7970                 ipr_cmd->job_step_failed = ipr_ioa_service_action_failed;
7971                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
7972                            IPR_SET_SUP_DEVICE_TIMEOUT);
7973
7974                 LEAVE;
7975                 return IPR_RC_JOB_RETURN;
7976         }
7977
7978         LEAVE;
7979         return IPR_RC_JOB_CONTINUE;
7980 }
7981
7982 /**
7983  * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
7984  * @ipr_cmd:    ipr command struct
7985  *
7986  * This utility function sends an inquiry to the adapter.
7987  *
7988  * Return value:
7989  *      none
7990  **/
7991 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
7992                               dma_addr_t dma_addr, u8 xfer_len)
7993 {
7994         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
7995
7996         ENTER;
7997         ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
7998         ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
7999
8000         ioarcb->cmd_pkt.cdb[0] = INQUIRY;
8001         ioarcb->cmd_pkt.cdb[1] = flags;
8002         ioarcb->cmd_pkt.cdb[2] = page;
8003         ioarcb->cmd_pkt.cdb[4] = xfer_len;
8004
8005         ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
8006
8007         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
8008         LEAVE;
8009 }
8010
8011 /**
8012  * ipr_inquiry_page_supported - Is the given inquiry page supported
8013  * @page0:              inquiry page 0 buffer
8014  * @page:               page code.
8015  *
8016  * This function determines if the specified inquiry page is supported.
8017  *
8018  * Return value:
8019  *      1 if page is supported / 0 if not
8020  **/
8021 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
8022 {
8023         int i;
8024
8025         for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
8026                 if (page0->page[i] == page)
8027                         return 1;
8028
8029         return 0;
8030 }
8031
8032 /**
8033  * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
8034  * @ipr_cmd:    ipr command struct
8035  *
8036  * This function sends a Page 0xC4 inquiry to the adapter
8037  * to retrieve software VPD information.
8038  *
8039  * Return value:
8040  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8041  **/
8042 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd)
8043 {
8044         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8045         struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8046         struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
8047
8048         ENTER;
8049         ipr_cmd->job_step = ipr_ioafp_set_caching_parameters;
8050         memset(pageC4, 0, sizeof(*pageC4));
8051
8052         if (ipr_inquiry_page_supported(page0, 0xC4)) {
8053                 ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4,
8054                                   (ioa_cfg->vpd_cbs_dma
8055                                    + offsetof(struct ipr_misc_cbs,
8056                                               pageC4_data)),
8057                                   sizeof(struct ipr_inquiry_pageC4));
8058                 return IPR_RC_JOB_RETURN;
8059         }
8060
8061         LEAVE;
8062         return IPR_RC_JOB_CONTINUE;
8063 }
8064
8065 /**
8066  * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
8067  * @ipr_cmd:    ipr command struct
8068  *
8069  * This function sends a Page 0xD0 inquiry to the adapter
8070  * to retrieve adapter capabilities.
8071  *
8072  * Return value:
8073  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8074  **/
8075 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
8076 {
8077         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8078         struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
8079         struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
8080
8081         ENTER;
8082         ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry;
8083         memset(cap, 0, sizeof(*cap));
8084
8085         if (ipr_inquiry_page_supported(page0, 0xD0)) {
8086                 ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
8087                                   ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
8088                                   sizeof(struct ipr_inquiry_cap));
8089                 return IPR_RC_JOB_RETURN;
8090         }
8091
8092         LEAVE;
8093         return IPR_RC_JOB_CONTINUE;
8094 }
8095
8096 /**
8097  * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
8098  * @ipr_cmd:    ipr command struct
8099  *
8100  * This function sends a Page 3 inquiry to the adapter
8101  * to retrieve software VPD information.
8102  *
8103  * Return value:
8104  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8105  **/
8106 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
8107 {
8108         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8109
8110         ENTER;
8111
8112         ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
8113
8114         ipr_ioafp_inquiry(ipr_cmd, 1, 3,
8115                           ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
8116                           sizeof(struct ipr_inquiry_page3));
8117
8118         LEAVE;
8119         return IPR_RC_JOB_RETURN;
8120 }
8121
8122 /**
8123  * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
8124  * @ipr_cmd:    ipr command struct
8125  *
8126  * This function sends a Page 0 inquiry to the adapter
8127  * to retrieve supported inquiry pages.
8128  *
8129  * Return value:
8130  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8131  **/
8132 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
8133 {
8134         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8135         char type[5];
8136
8137         ENTER;
8138
8139         /* Grab the type out of the VPD and store it away */
8140         memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
8141         type[4] = '\0';
8142         ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
8143
8144         if (ipr_invalid_adapter(ioa_cfg)) {
8145                 dev_err(&ioa_cfg->pdev->dev,
8146                         "Adapter not supported in this hardware configuration.\n");
8147
8148                 if (!ipr_testmode) {
8149                         ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
8150                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
8151                         list_add_tail(&ipr_cmd->queue,
8152                                         &ioa_cfg->hrrq->hrrq_free_q);
8153                         return IPR_RC_JOB_RETURN;
8154                 }
8155         }
8156
8157         ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
8158
8159         ipr_ioafp_inquiry(ipr_cmd, 1, 0,
8160                           ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
8161                           sizeof(struct ipr_inquiry_page0));
8162
8163         LEAVE;
8164         return IPR_RC_JOB_RETURN;
8165 }
8166
8167 /**
8168  * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
8169  * @ipr_cmd:    ipr command struct
8170  *
8171  * This function sends a standard inquiry to the adapter.
8172  *
8173  * Return value:
8174  *      IPR_RC_JOB_RETURN
8175  **/
8176 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
8177 {
8178         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8179
8180         ENTER;
8181         ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
8182
8183         ipr_ioafp_inquiry(ipr_cmd, 0, 0,
8184                           ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
8185                           sizeof(struct ipr_ioa_vpd));
8186
8187         LEAVE;
8188         return IPR_RC_JOB_RETURN;
8189 }
8190
8191 /**
8192  * ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
8193  * @ipr_cmd:    ipr command struct
8194  *
8195  * This function send an Identify Host Request Response Queue
8196  * command to establish the HRRQ with the adapter.
8197  *
8198  * Return value:
8199  *      IPR_RC_JOB_RETURN
8200  **/
8201 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
8202 {
8203         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8204         struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
8205         struct ipr_hrr_queue *hrrq;
8206
8207         ENTER;
8208         ipr_cmd->job_step = ipr_ioafp_std_inquiry;
8209         if (ioa_cfg->identify_hrrq_index == 0)
8210                 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
8211
8212         if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) {
8213                 hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index];
8214
8215                 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
8216                 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
8217
8218                 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
8219                 if (ioa_cfg->sis64)
8220                         ioarcb->cmd_pkt.cdb[1] = 0x1;
8221
8222                 if (ioa_cfg->nvectors == 1)
8223                         ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE;
8224                 else
8225                         ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE;
8226
8227                 ioarcb->cmd_pkt.cdb[2] =
8228                         ((u64) hrrq->host_rrq_dma >> 24) & 0xff;
8229                 ioarcb->cmd_pkt.cdb[3] =
8230                         ((u64) hrrq->host_rrq_dma >> 16) & 0xff;
8231                 ioarcb->cmd_pkt.cdb[4] =
8232                         ((u64) hrrq->host_rrq_dma >> 8) & 0xff;
8233                 ioarcb->cmd_pkt.cdb[5] =
8234                         ((u64) hrrq->host_rrq_dma) & 0xff;
8235                 ioarcb->cmd_pkt.cdb[7] =
8236                         ((sizeof(u32) * hrrq->size) >> 8) & 0xff;
8237                 ioarcb->cmd_pkt.cdb[8] =
8238                         (sizeof(u32) * hrrq->size) & 0xff;
8239
8240                 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8241                         ioarcb->cmd_pkt.cdb[9] =
8242                                         ioa_cfg->identify_hrrq_index;
8243
8244                 if (ioa_cfg->sis64) {
8245                         ioarcb->cmd_pkt.cdb[10] =
8246                                 ((u64) hrrq->host_rrq_dma >> 56) & 0xff;
8247                         ioarcb->cmd_pkt.cdb[11] =
8248                                 ((u64) hrrq->host_rrq_dma >> 48) & 0xff;
8249                         ioarcb->cmd_pkt.cdb[12] =
8250                                 ((u64) hrrq->host_rrq_dma >> 40) & 0xff;
8251                         ioarcb->cmd_pkt.cdb[13] =
8252                                 ((u64) hrrq->host_rrq_dma >> 32) & 0xff;
8253                 }
8254
8255                 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
8256                         ioarcb->cmd_pkt.cdb[14] =
8257                                         ioa_cfg->identify_hrrq_index;
8258
8259                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
8260                            IPR_INTERNAL_TIMEOUT);
8261
8262                 if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num)
8263                         ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8264
8265                 LEAVE;
8266                 return IPR_RC_JOB_RETURN;
8267         }
8268
8269         LEAVE;
8270         return IPR_RC_JOB_CONTINUE;
8271 }
8272
8273 /**
8274  * ipr_reset_timer_done - Adapter reset timer function
8275  * @ipr_cmd:    ipr command struct
8276  *
8277  * Description: This function is used in adapter reset processing
8278  * for timing events. If the reset_cmd pointer in the IOA
8279  * config struct is not this adapter's we are doing nested
8280  * resets and fail_all_ops will take care of freeing the
8281  * command block.
8282  *
8283  * Return value:
8284  *      none
8285  **/
8286 static void ipr_reset_timer_done(struct timer_list *t)
8287 {
8288         struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
8289         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8290         unsigned long lock_flags = 0;
8291
8292         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8293
8294         if (ioa_cfg->reset_cmd == ipr_cmd) {
8295                 list_del(&ipr_cmd->queue);
8296                 ipr_cmd->done(ipr_cmd);
8297         }
8298
8299         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8300 }
8301
8302 /**
8303  * ipr_reset_start_timer - Start a timer for adapter reset job
8304  * @ipr_cmd:    ipr command struct
8305  * @timeout:    timeout value
8306  *
8307  * Description: This function is used in adapter reset processing
8308  * for timing events. If the reset_cmd pointer in the IOA
8309  * config struct is not this adapter's we are doing nested
8310  * resets and fail_all_ops will take care of freeing the
8311  * command block.
8312  *
8313  * Return value:
8314  *      none
8315  **/
8316 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
8317                                   unsigned long timeout)
8318 {
8319
8320         ENTER;
8321         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8322         ipr_cmd->done = ipr_reset_ioa_job;
8323
8324         ipr_cmd->timer.expires = jiffies + timeout;
8325         ipr_cmd->timer.function = ipr_reset_timer_done;
8326         add_timer(&ipr_cmd->timer);
8327 }
8328
8329 /**
8330  * ipr_init_ioa_mem - Initialize ioa_cfg control block
8331  * @ioa_cfg:    ioa cfg struct
8332  *
8333  * Return value:
8334  *      nothing
8335  **/
8336 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
8337 {
8338         struct ipr_hrr_queue *hrrq;
8339
8340         for_each_hrrq(hrrq, ioa_cfg) {
8341                 spin_lock(&hrrq->_lock);
8342                 memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size);
8343
8344                 /* Initialize Host RRQ pointers */
8345                 hrrq->hrrq_start = hrrq->host_rrq;
8346                 hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1];
8347                 hrrq->hrrq_curr = hrrq->hrrq_start;
8348                 hrrq->toggle_bit = 1;
8349                 spin_unlock(&hrrq->_lock);
8350         }
8351         wmb();
8352
8353         ioa_cfg->identify_hrrq_index = 0;
8354         if (ioa_cfg->hrrq_num == 1)
8355                 atomic_set(&ioa_cfg->hrrq_index, 0);
8356         else
8357                 atomic_set(&ioa_cfg->hrrq_index, 1);
8358
8359         /* Zero out config table */
8360         memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
8361 }
8362
8363 /**
8364  * ipr_reset_next_stage - Process IPL stage change based on feedback register.
8365  * @ipr_cmd:    ipr command struct
8366  *
8367  * Return value:
8368  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8369  **/
8370 static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
8371 {
8372         unsigned long stage, stage_time;
8373         u32 feedback;
8374         volatile u32 int_reg;
8375         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8376         u64 maskval = 0;
8377
8378         feedback = readl(ioa_cfg->regs.init_feedback_reg);
8379         stage = feedback & IPR_IPL_INIT_STAGE_MASK;
8380         stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
8381
8382         ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
8383
8384         /* sanity check the stage_time value */
8385         if (stage_time == 0)
8386                 stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
8387         else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
8388                 stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
8389         else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
8390                 stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
8391
8392         if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
8393                 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
8394                 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8395                 stage_time = ioa_cfg->transop_timeout;
8396                 ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8397         } else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
8398                 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8399                 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8400                         ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8401                         maskval = IPR_PCII_IPL_STAGE_CHANGE;
8402                         maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
8403                         writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
8404                         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8405                         return IPR_RC_JOB_CONTINUE;
8406                 }
8407         }
8408
8409         ipr_cmd->timer.expires = jiffies + stage_time * HZ;
8410         ipr_cmd->timer.function = ipr_oper_timeout;
8411         ipr_cmd->done = ipr_reset_ioa_job;
8412         add_timer(&ipr_cmd->timer);
8413
8414         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8415
8416         return IPR_RC_JOB_RETURN;
8417 }
8418
8419 /**
8420  * ipr_reset_enable_ioa - Enable the IOA following a reset.
8421  * @ipr_cmd:    ipr command struct
8422  *
8423  * This function reinitializes some control blocks and
8424  * enables destructive diagnostics on the adapter.
8425  *
8426  * Return value:
8427  *      IPR_RC_JOB_RETURN
8428  **/
8429 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
8430 {
8431         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8432         volatile u32 int_reg;
8433         volatile u64 maskval;
8434         int i;
8435
8436         ENTER;
8437         ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
8438         ipr_init_ioa_mem(ioa_cfg);
8439
8440         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
8441                 spin_lock(&ioa_cfg->hrrq[i]._lock);
8442                 ioa_cfg->hrrq[i].allow_interrupts = 1;
8443                 spin_unlock(&ioa_cfg->hrrq[i]._lock);
8444         }
8445         if (ioa_cfg->sis64) {
8446                 /* Set the adapter to the correct endian mode. */
8447                 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8448                 int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8449         }
8450
8451         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
8452
8453         if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
8454                 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
8455                        ioa_cfg->regs.clr_interrupt_mask_reg32);
8456                 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8457                 return IPR_RC_JOB_CONTINUE;
8458         }
8459
8460         /* Enable destructive diagnostics on IOA */
8461         writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
8462
8463         if (ioa_cfg->sis64) {
8464                 maskval = IPR_PCII_IPL_STAGE_CHANGE;
8465                 maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
8466                 writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
8467         } else
8468                 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
8469
8470         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
8471
8472         dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
8473
8474         if (ioa_cfg->sis64) {
8475                 ipr_cmd->job_step = ipr_reset_next_stage;
8476                 return IPR_RC_JOB_CONTINUE;
8477         }
8478
8479         ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
8480         ipr_cmd->timer.function = ipr_oper_timeout;
8481         ipr_cmd->done = ipr_reset_ioa_job;
8482         add_timer(&ipr_cmd->timer);
8483         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
8484
8485         LEAVE;
8486         return IPR_RC_JOB_RETURN;
8487 }
8488
8489 /**
8490  * ipr_reset_wait_for_dump - Wait for a dump to timeout.
8491  * @ipr_cmd:    ipr command struct
8492  *
8493  * This function is invoked when an adapter dump has run out
8494  * of processing time.
8495  *
8496  * Return value:
8497  *      IPR_RC_JOB_CONTINUE
8498  **/
8499 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
8500 {
8501         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8502
8503         if (ioa_cfg->sdt_state == GET_DUMP)
8504                 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8505         else if (ioa_cfg->sdt_state == READ_DUMP)
8506                 ioa_cfg->sdt_state = ABORT_DUMP;
8507
8508         ioa_cfg->dump_timeout = 1;
8509         ipr_cmd->job_step = ipr_reset_alert;
8510
8511         return IPR_RC_JOB_CONTINUE;
8512 }
8513
8514 /**
8515  * ipr_unit_check_no_data - Log a unit check/no data error log
8516  * @ioa_cfg:            ioa config struct
8517  *
8518  * Logs an error indicating the adapter unit checked, but for some
8519  * reason, we were unable to fetch the unit check buffer.
8520  *
8521  * Return value:
8522  *      nothing
8523  **/
8524 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
8525 {
8526         ioa_cfg->errors_logged++;
8527         dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
8528 }
8529
8530 /**
8531  * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
8532  * @ioa_cfg:            ioa config struct
8533  *
8534  * Fetches the unit check buffer from the adapter by clocking the data
8535  * through the mailbox register.
8536  *
8537  * Return value:
8538  *      nothing
8539  **/
8540 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
8541 {
8542         unsigned long mailbox;
8543         struct ipr_hostrcb *hostrcb;
8544         struct ipr_uc_sdt sdt;
8545         int rc, length;
8546         u32 ioasc;
8547
8548         mailbox = readl(ioa_cfg->ioa_mailbox);
8549
8550         if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
8551                 ipr_unit_check_no_data(ioa_cfg);
8552                 return;
8553         }
8554
8555         memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
8556         rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
8557                                         (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
8558
8559         if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
8560             ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
8561             (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
8562                 ipr_unit_check_no_data(ioa_cfg);
8563                 return;
8564         }
8565
8566         /* Find length of the first sdt entry (UC buffer) */
8567         if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
8568                 length = be32_to_cpu(sdt.entry[0].end_token);
8569         else
8570                 length = (be32_to_cpu(sdt.entry[0].end_token) -
8571                           be32_to_cpu(sdt.entry[0].start_token)) &
8572                           IPR_FMT2_MBX_ADDR_MASK;
8573
8574         hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
8575                              struct ipr_hostrcb, queue);
8576         list_del_init(&hostrcb->queue);
8577         memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
8578
8579         rc = ipr_get_ldump_data_section(ioa_cfg,
8580                                         be32_to_cpu(sdt.entry[0].start_token),
8581                                         (__be32 *)&hostrcb->hcam,
8582                                         min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
8583
8584         if (!rc) {
8585                 ipr_handle_log_data(ioa_cfg, hostrcb);
8586                 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
8587                 if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
8588                     ioa_cfg->sdt_state == GET_DUMP)
8589                         ioa_cfg->sdt_state = WAIT_FOR_DUMP;
8590         } else
8591                 ipr_unit_check_no_data(ioa_cfg);
8592
8593         list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
8594 }
8595
8596 /**
8597  * ipr_reset_get_unit_check_job - Call to get the unit check buffer.
8598  * @ipr_cmd:    ipr command struct
8599  *
8600  * Description: This function will call to get the unit check buffer.
8601  *
8602  * Return value:
8603  *      IPR_RC_JOB_RETURN
8604  **/
8605 static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
8606 {
8607         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8608
8609         ENTER;
8610         ioa_cfg->ioa_unit_checked = 0;
8611         ipr_get_unit_check_buffer(ioa_cfg);
8612         ipr_cmd->job_step = ipr_reset_alert;
8613         ipr_reset_start_timer(ipr_cmd, 0);
8614
8615         LEAVE;
8616         return IPR_RC_JOB_RETURN;
8617 }
8618
8619 static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd)
8620 {
8621         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8622
8623         ENTER;
8624
8625         if (ioa_cfg->sdt_state != GET_DUMP)
8626                 return IPR_RC_JOB_RETURN;
8627
8628         if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left ||
8629             (readl(ioa_cfg->regs.sense_interrupt_reg) &
8630              IPR_PCII_MAILBOX_STABLE)) {
8631
8632                 if (!ipr_cmd->u.time_left)
8633                         dev_err(&ioa_cfg->pdev->dev,
8634                                 "Timed out waiting for Mailbox register.\n");
8635
8636                 ioa_cfg->sdt_state = READ_DUMP;
8637                 ioa_cfg->dump_timeout = 0;
8638                 if (ioa_cfg->sis64)
8639                         ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
8640                 else
8641                         ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
8642                 ipr_cmd->job_step = ipr_reset_wait_for_dump;
8643                 schedule_work(&ioa_cfg->work_q);
8644
8645         } else {
8646                 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8647                 ipr_reset_start_timer(ipr_cmd,
8648                                       IPR_CHECK_FOR_RESET_TIMEOUT);
8649         }
8650
8651         LEAVE;
8652         return IPR_RC_JOB_RETURN;
8653 }
8654
8655 /**
8656  * ipr_reset_restore_cfg_space - Restore PCI config space.
8657  * @ipr_cmd:    ipr command struct
8658  *
8659  * Description: This function restores the saved PCI config space of
8660  * the adapter, fails all outstanding ops back to the callers, and
8661  * fetches the dump/unit check if applicable to this reset.
8662  *
8663  * Return value:
8664  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8665  **/
8666 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
8667 {
8668         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8669         u32 int_reg;
8670
8671         ENTER;
8672         ioa_cfg->pdev->state_saved = true;
8673         pci_restore_state(ioa_cfg->pdev);
8674
8675         if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
8676                 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8677                 return IPR_RC_JOB_CONTINUE;
8678         }
8679
8680         ipr_fail_all_ops(ioa_cfg);
8681
8682         if (ioa_cfg->sis64) {
8683                 /* Set the adapter to the correct endian mode. */
8684                 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
8685                 int_reg = readl(ioa_cfg->regs.endian_swap_reg);
8686         }
8687
8688         if (ioa_cfg->ioa_unit_checked) {
8689                 if (ioa_cfg->sis64) {
8690                         ipr_cmd->job_step = ipr_reset_get_unit_check_job;
8691                         ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
8692                         return IPR_RC_JOB_RETURN;
8693                 } else {
8694                         ioa_cfg->ioa_unit_checked = 0;
8695                         ipr_get_unit_check_buffer(ioa_cfg);
8696                         ipr_cmd->job_step = ipr_reset_alert;
8697                         ipr_reset_start_timer(ipr_cmd, 0);
8698                         return IPR_RC_JOB_RETURN;
8699                 }
8700         }
8701
8702         if (ioa_cfg->in_ioa_bringdown) {
8703                 ipr_cmd->job_step = ipr_ioa_bringdown_done;
8704         } else if (ioa_cfg->sdt_state == GET_DUMP) {
8705                 ipr_cmd->job_step = ipr_dump_mailbox_wait;
8706                 ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX;
8707         } else {
8708                 ipr_cmd->job_step = ipr_reset_enable_ioa;
8709         }
8710
8711         LEAVE;
8712         return IPR_RC_JOB_CONTINUE;
8713 }
8714
8715 /**
8716  * ipr_reset_bist_done - BIST has completed on the adapter.
8717  * @ipr_cmd:    ipr command struct
8718  *
8719  * Description: Unblock config space and resume the reset process.
8720  *
8721  * Return value:
8722  *      IPR_RC_JOB_CONTINUE
8723  **/
8724 static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
8725 {
8726         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8727
8728         ENTER;
8729         if (ioa_cfg->cfg_locked)
8730                 pci_cfg_access_unlock(ioa_cfg->pdev);
8731         ioa_cfg->cfg_locked = 0;
8732         ipr_cmd->job_step = ipr_reset_restore_cfg_space;
8733         LEAVE;
8734         return IPR_RC_JOB_CONTINUE;
8735 }
8736
8737 /**
8738  * ipr_reset_start_bist - Run BIST on the adapter.
8739  * @ipr_cmd:    ipr command struct
8740  *
8741  * Description: This function runs BIST on the adapter, then delays 2 seconds.
8742  *
8743  * Return value:
8744  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8745  **/
8746 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
8747 {
8748         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8749         int rc = PCIBIOS_SUCCESSFUL;
8750
8751         ENTER;
8752         if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO)
8753                 writel(IPR_UPROCI_SIS64_START_BIST,
8754                        ioa_cfg->regs.set_uproc_interrupt_reg32);
8755         else
8756                 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
8757
8758         if (rc == PCIBIOS_SUCCESSFUL) {
8759                 ipr_cmd->job_step = ipr_reset_bist_done;
8760                 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8761                 rc = IPR_RC_JOB_RETURN;
8762         } else {
8763                 if (ioa_cfg->cfg_locked)
8764                         pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev);
8765                 ioa_cfg->cfg_locked = 0;
8766                 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
8767                 rc = IPR_RC_JOB_CONTINUE;
8768         }
8769
8770         LEAVE;
8771         return rc;
8772 }
8773
8774 /**
8775  * ipr_reset_slot_reset_done - Clear PCI reset to the adapter
8776  * @ipr_cmd:    ipr command struct
8777  *
8778  * Description: This clears PCI reset to the adapter and delays two seconds.
8779  *
8780  * Return value:
8781  *      IPR_RC_JOB_RETURN
8782  **/
8783 static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
8784 {
8785         ENTER;
8786         ipr_cmd->job_step = ipr_reset_bist_done;
8787         ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
8788         LEAVE;
8789         return IPR_RC_JOB_RETURN;
8790 }
8791
8792 /**
8793  * ipr_reset_reset_work - Pulse a PCIe fundamental reset
8794  * @work:       work struct
8795  *
8796  * Description: This pulses warm reset to a slot.
8797  *
8798  **/
8799 static void ipr_reset_reset_work(struct work_struct *work)
8800 {
8801         struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work);
8802         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8803         struct pci_dev *pdev = ioa_cfg->pdev;
8804         unsigned long lock_flags = 0;
8805
8806         ENTER;
8807         pci_set_pcie_reset_state(pdev, pcie_warm_reset);
8808         msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT));
8809         pci_set_pcie_reset_state(pdev, pcie_deassert_reset);
8810
8811         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
8812         if (ioa_cfg->reset_cmd == ipr_cmd)
8813                 ipr_reset_ioa_job(ipr_cmd);
8814         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
8815         LEAVE;
8816 }
8817
8818 /**
8819  * ipr_reset_slot_reset - Reset the PCI slot of the adapter.
8820  * @ipr_cmd:    ipr command struct
8821  *
8822  * Description: This asserts PCI reset to the adapter.
8823  *
8824  * Return value:
8825  *      IPR_RC_JOB_RETURN
8826  **/
8827 static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
8828 {
8829         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8830
8831         ENTER;
8832         INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work);
8833         queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work);
8834         ipr_cmd->job_step = ipr_reset_slot_reset_done;
8835         LEAVE;
8836         return IPR_RC_JOB_RETURN;
8837 }
8838
8839 /**
8840  * ipr_reset_block_config_access_wait - Wait for permission to block config access
8841  * @ipr_cmd:    ipr command struct
8842  *
8843  * Description: This attempts to block config access to the IOA.
8844  *
8845  * Return value:
8846  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8847  **/
8848 static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd)
8849 {
8850         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8851         int rc = IPR_RC_JOB_CONTINUE;
8852
8853         if (pci_cfg_access_trylock(ioa_cfg->pdev)) {
8854                 ioa_cfg->cfg_locked = 1;
8855                 ipr_cmd->job_step = ioa_cfg->reset;
8856         } else {
8857                 if (ipr_cmd->u.time_left) {
8858                         rc = IPR_RC_JOB_RETURN;
8859                         ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8860                         ipr_reset_start_timer(ipr_cmd,
8861                                               IPR_CHECK_FOR_RESET_TIMEOUT);
8862                 } else {
8863                         ipr_cmd->job_step = ioa_cfg->reset;
8864                         dev_err(&ioa_cfg->pdev->dev,
8865                                 "Timed out waiting to lock config access. Resetting anyway.\n");
8866                 }
8867         }
8868
8869         return rc;
8870 }
8871
8872 /**
8873  * ipr_reset_block_config_access - Block config access to the IOA
8874  * @ipr_cmd:    ipr command struct
8875  *
8876  * Description: This attempts to block config access to the IOA
8877  *
8878  * Return value:
8879  *      IPR_RC_JOB_CONTINUE
8880  **/
8881 static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd)
8882 {
8883         ipr_cmd->ioa_cfg->cfg_locked = 0;
8884         ipr_cmd->job_step = ipr_reset_block_config_access_wait;
8885         ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8886         return IPR_RC_JOB_CONTINUE;
8887 }
8888
8889 /**
8890  * ipr_reset_allowed - Query whether or not IOA can be reset
8891  * @ioa_cfg:    ioa config struct
8892  *
8893  * Return value:
8894  *      0 if reset not allowed / non-zero if reset is allowed
8895  **/
8896 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
8897 {
8898         volatile u32 temp_reg;
8899
8900         temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
8901         return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
8902 }
8903
8904 /**
8905  * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
8906  * @ipr_cmd:    ipr command struct
8907  *
8908  * Description: This function waits for adapter permission to run BIST,
8909  * then runs BIST. If the adapter does not give permission after a
8910  * reasonable time, we will reset the adapter anyway. The impact of
8911  * resetting the adapter without warning the adapter is the risk of
8912  * losing the persistent error log on the adapter. If the adapter is
8913  * reset while it is writing to the flash on the adapter, the flash
8914  * segment will have bad ECC and be zeroed.
8915  *
8916  * Return value:
8917  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
8918  **/
8919 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
8920 {
8921         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8922         int rc = IPR_RC_JOB_RETURN;
8923
8924         if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
8925                 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
8926                 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8927         } else {
8928                 ipr_cmd->job_step = ipr_reset_block_config_access;
8929                 rc = IPR_RC_JOB_CONTINUE;
8930         }
8931
8932         return rc;
8933 }
8934
8935 /**
8936  * ipr_reset_alert - Alert the adapter of a pending reset
8937  * @ipr_cmd:    ipr command struct
8938  *
8939  * Description: This function alerts the adapter that it will be reset.
8940  * If memory space is not currently enabled, proceed directly
8941  * to running BIST on the adapter. The timer must always be started
8942  * so we guarantee we do not run BIST from ipr_isr.
8943  *
8944  * Return value:
8945  *      IPR_RC_JOB_RETURN
8946  **/
8947 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
8948 {
8949         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8950         u16 cmd_reg;
8951         int rc;
8952
8953         ENTER;
8954         rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
8955
8956         if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
8957                 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
8958                 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
8959                 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
8960         } else {
8961                 ipr_cmd->job_step = ipr_reset_block_config_access;
8962         }
8963
8964         ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
8965         ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
8966
8967         LEAVE;
8968         return IPR_RC_JOB_RETURN;
8969 }
8970
8971 /**
8972  * ipr_reset_quiesce_done - Complete IOA disconnect
8973  * @ipr_cmd:    ipr command struct
8974  *
8975  * Description: Freeze the adapter to complete quiesce processing
8976  *
8977  * Return value:
8978  *      IPR_RC_JOB_CONTINUE
8979  **/
8980 static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd)
8981 {
8982         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
8983
8984         ENTER;
8985         ipr_cmd->job_step = ipr_ioa_bringdown_done;
8986         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
8987         LEAVE;
8988         return IPR_RC_JOB_CONTINUE;
8989 }
8990
8991 /**
8992  * ipr_reset_cancel_hcam_done - Check for outstanding commands
8993  * @ipr_cmd:    ipr command struct
8994  *
8995  * Description: Ensure nothing is outstanding to the IOA and
8996  *                      proceed with IOA disconnect. Otherwise reset the IOA.
8997  *
8998  * Return value:
8999  *      IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
9000  **/
9001 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd)
9002 {
9003         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9004         struct ipr_cmnd *loop_cmd;
9005         struct ipr_hrr_queue *hrrq;
9006         int rc = IPR_RC_JOB_CONTINUE;
9007         int count = 0;
9008
9009         ENTER;
9010         ipr_cmd->job_step = ipr_reset_quiesce_done;
9011
9012         for_each_hrrq(hrrq, ioa_cfg) {
9013                 spin_lock(&hrrq->_lock);
9014                 list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) {
9015                         count++;
9016                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9017                         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9018                         rc = IPR_RC_JOB_RETURN;
9019                         break;
9020                 }
9021                 spin_unlock(&hrrq->_lock);
9022
9023                 if (count)
9024                         break;
9025         }
9026
9027         LEAVE;
9028         return rc;
9029 }
9030
9031 /**
9032  * ipr_reset_cancel_hcam - Cancel outstanding HCAMs
9033  * @ipr_cmd:    ipr command struct
9034  *
9035  * Description: Cancel any oustanding HCAMs to the IOA.
9036  *
9037  * Return value:
9038  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9039  **/
9040 static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd)
9041 {
9042         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9043         int rc = IPR_RC_JOB_CONTINUE;
9044         struct ipr_cmd_pkt *cmd_pkt;
9045         struct ipr_cmnd *hcam_cmd;
9046         struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ];
9047
9048         ENTER;
9049         ipr_cmd->job_step = ipr_reset_cancel_hcam_done;
9050
9051         if (!hrrq->ioa_is_dead) {
9052                 if (!list_empty(&ioa_cfg->hostrcb_pending_q)) {
9053                         list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) {
9054                                 if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC)
9055                                         continue;
9056
9057                                 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9058                                 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9059                                 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
9060                                 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
9061                                 cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST;
9062                                 cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB;
9063                                 cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff;
9064                                 cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff;
9065                                 cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff;
9066                                 cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff;
9067                                 cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff;
9068                                 cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff;
9069                                 cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff;
9070                                 cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff;
9071
9072                                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9073                                            IPR_CANCEL_TIMEOUT);
9074
9075                                 rc = IPR_RC_JOB_RETURN;
9076                                 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9077                                 break;
9078                         }
9079                 }
9080         } else
9081                 ipr_cmd->job_step = ipr_reset_alert;
9082
9083         LEAVE;
9084         return rc;
9085 }
9086
9087 /**
9088  * ipr_reset_ucode_download_done - Microcode download completion
9089  * @ipr_cmd:    ipr command struct
9090  *
9091  * Description: This function unmaps the microcode download buffer.
9092  *
9093  * Return value:
9094  *      IPR_RC_JOB_CONTINUE
9095  **/
9096 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
9097 {
9098         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9099         struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9100
9101         dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
9102                      sglist->num_sg, DMA_TO_DEVICE);
9103
9104         ipr_cmd->job_step = ipr_reset_alert;
9105         return IPR_RC_JOB_CONTINUE;
9106 }
9107
9108 /**
9109  * ipr_reset_ucode_download - Download microcode to the adapter
9110  * @ipr_cmd:    ipr command struct
9111  *
9112  * Description: This function checks to see if it there is microcode
9113  * to download to the adapter. If there is, a download is performed.
9114  *
9115  * Return value:
9116  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9117  **/
9118 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
9119 {
9120         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9121         struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
9122
9123         ENTER;
9124         ipr_cmd->job_step = ipr_reset_alert;
9125
9126         if (!sglist)
9127                 return IPR_RC_JOB_CONTINUE;
9128
9129         ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9130         ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
9131         ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
9132         ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
9133         ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
9134         ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
9135         ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
9136
9137         if (ioa_cfg->sis64)
9138                 ipr_build_ucode_ioadl64(ipr_cmd, sglist);
9139         else
9140                 ipr_build_ucode_ioadl(ipr_cmd, sglist);
9141         ipr_cmd->job_step = ipr_reset_ucode_download_done;
9142
9143         ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
9144                    IPR_WRITE_BUFFER_TIMEOUT);
9145
9146         LEAVE;
9147         return IPR_RC_JOB_RETURN;
9148 }
9149
9150 /**
9151  * ipr_reset_shutdown_ioa - Shutdown the adapter
9152  * @ipr_cmd:    ipr command struct
9153  *
9154  * Description: This function issues an adapter shutdown of the
9155  * specified type to the specified adapter as part of the
9156  * adapter reset job.
9157  *
9158  * Return value:
9159  *      IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
9160  **/
9161 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
9162 {
9163         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9164         enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
9165         unsigned long timeout;
9166         int rc = IPR_RC_JOB_CONTINUE;
9167
9168         ENTER;
9169         if (shutdown_type == IPR_SHUTDOWN_QUIESCE)
9170                 ipr_cmd->job_step = ipr_reset_cancel_hcam;
9171         else if (shutdown_type != IPR_SHUTDOWN_NONE &&
9172                         !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
9173                 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
9174                 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
9175                 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
9176                 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
9177
9178                 if (shutdown_type == IPR_SHUTDOWN_NORMAL)
9179                         timeout = IPR_SHUTDOWN_TIMEOUT;
9180                 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
9181                         timeout = IPR_INTERNAL_TIMEOUT;
9182                 else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
9183                         timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
9184                 else
9185                         timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
9186
9187                 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
9188
9189                 rc = IPR_RC_JOB_RETURN;
9190                 ipr_cmd->job_step = ipr_reset_ucode_download;
9191         } else
9192                 ipr_cmd->job_step = ipr_reset_alert;
9193
9194         LEAVE;
9195         return rc;
9196 }
9197
9198 /**
9199  * ipr_reset_ioa_job - Adapter reset job
9200  * @ipr_cmd:    ipr command struct
9201  *
9202  * Description: This function is the job router for the adapter reset job.
9203  *
9204  * Return value:
9205  *      none
9206  **/
9207 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
9208 {
9209         u32 rc, ioasc;
9210         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9211
9212         do {
9213                 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
9214
9215                 if (ioa_cfg->reset_cmd != ipr_cmd) {
9216                         /*
9217                          * We are doing nested adapter resets and this is
9218                          * not the current reset job.
9219                          */
9220                         list_add_tail(&ipr_cmd->queue,
9221                                         &ipr_cmd->hrrq->hrrq_free_q);
9222                         return;
9223                 }
9224
9225                 if (IPR_IOASC_SENSE_KEY(ioasc)) {
9226                         rc = ipr_cmd->job_step_failed(ipr_cmd);
9227                         if (rc == IPR_RC_JOB_RETURN)
9228                                 return;
9229                 }
9230
9231                 ipr_reinit_ipr_cmnd(ipr_cmd);
9232                 ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
9233                 rc = ipr_cmd->job_step(ipr_cmd);
9234         } while (rc == IPR_RC_JOB_CONTINUE);
9235 }
9236
9237 /**
9238  * _ipr_initiate_ioa_reset - Initiate an adapter reset
9239  * @ioa_cfg:            ioa config struct
9240  * @job_step:           first job step of reset job
9241  * @shutdown_type:      shutdown type
9242  *
9243  * Description: This function will initiate the reset of the given adapter
9244  * starting at the selected job step.
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                                     int (*job_step) (struct ipr_cmnd *),
9253                                     enum ipr_shutdown_type shutdown_type)
9254 {
9255         struct ipr_cmnd *ipr_cmd;
9256         int i;
9257
9258         ioa_cfg->in_reset_reload = 1;
9259         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9260                 spin_lock(&ioa_cfg->hrrq[i]._lock);
9261                 ioa_cfg->hrrq[i].allow_cmds = 0;
9262                 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9263         }
9264         wmb();
9265         if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9266                 ioa_cfg->scsi_unblock = 0;
9267                 ioa_cfg->scsi_blocked = 1;
9268                 scsi_block_requests(ioa_cfg->host);
9269         }
9270
9271         ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
9272         ioa_cfg->reset_cmd = ipr_cmd;
9273         ipr_cmd->job_step = job_step;
9274         ipr_cmd->u.shutdown_type = shutdown_type;
9275
9276         ipr_reset_ioa_job(ipr_cmd);
9277 }
9278
9279 /**
9280  * ipr_initiate_ioa_reset - Initiate an adapter reset
9281  * @ioa_cfg:            ioa config struct
9282  * @shutdown_type:      shutdown type
9283  *
9284  * Description: This function will initiate the reset of the given adapter.
9285  * If the caller needs to wait on the completion of the reset,
9286  * the caller must sleep on the reset_wait_q.
9287  *
9288  * Return value:
9289  *      none
9290  **/
9291 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
9292                                    enum ipr_shutdown_type shutdown_type)
9293 {
9294         int i;
9295
9296         if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
9297                 return;
9298
9299         if (ioa_cfg->in_reset_reload) {
9300                 if (ioa_cfg->sdt_state == GET_DUMP)
9301                         ioa_cfg->sdt_state = WAIT_FOR_DUMP;
9302                 else if (ioa_cfg->sdt_state == READ_DUMP)
9303                         ioa_cfg->sdt_state = ABORT_DUMP;
9304         }
9305
9306         if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
9307                 dev_err(&ioa_cfg->pdev->dev,
9308                         "IOA taken offline - error recovery failed\n");
9309
9310                 ioa_cfg->reset_retries = 0;
9311                 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9312                         spin_lock(&ioa_cfg->hrrq[i]._lock);
9313                         ioa_cfg->hrrq[i].ioa_is_dead = 1;
9314                         spin_unlock(&ioa_cfg->hrrq[i]._lock);
9315                 }
9316                 wmb();
9317
9318                 if (ioa_cfg->in_ioa_bringdown) {
9319                         ioa_cfg->reset_cmd = NULL;
9320                         ioa_cfg->in_reset_reload = 0;
9321                         ipr_fail_all_ops(ioa_cfg);
9322                         wake_up_all(&ioa_cfg->reset_wait_q);
9323
9324                         if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
9325                                 ioa_cfg->scsi_unblock = 1;
9326                                 schedule_work(&ioa_cfg->work_q);
9327                         }
9328                         return;
9329                 } else {
9330                         ioa_cfg->in_ioa_bringdown = 1;
9331                         shutdown_type = IPR_SHUTDOWN_NONE;
9332                 }
9333         }
9334
9335         _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
9336                                 shutdown_type);
9337 }
9338
9339 /**
9340  * ipr_reset_freeze - Hold off all I/O activity
9341  * @ipr_cmd:    ipr command struct
9342  *
9343  * Description: If the PCI slot is frozen, hold off all I/O
9344  * activity; then, as soon as the slot is available again,
9345  * initiate an adapter reset.
9346  */
9347 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
9348 {
9349         struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
9350         int i;
9351
9352         /* Disallow new interrupts, avoid loop */
9353         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9354                 spin_lock(&ioa_cfg->hrrq[i]._lock);
9355                 ioa_cfg->hrrq[i].allow_interrupts = 0;
9356                 spin_unlock(&ioa_cfg->hrrq[i]._lock);
9357         }
9358         wmb();
9359         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
9360         ipr_cmd->done = ipr_reset_ioa_job;
9361         return IPR_RC_JOB_RETURN;
9362 }
9363
9364 /**
9365  * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
9366  * @pdev:       PCI device struct
9367  *
9368  * Description: This routine is called to tell us that the MMIO
9369  * access to the IOA has been restored
9370  */
9371 static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev)
9372 {
9373         unsigned long flags = 0;
9374         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9375
9376         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9377         if (!ioa_cfg->probe_done)
9378                 pci_save_state(pdev);
9379         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9380         return PCI_ERS_RESULT_NEED_RESET;
9381 }
9382
9383 /**
9384  * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
9385  * @pdev:       PCI device struct
9386  *
9387  * Description: This routine is called to tell us that the PCI bus
9388  * is down. Can't do anything here, except put the device driver
9389  * into a holding pattern, waiting for the PCI bus to come back.
9390  */
9391 static void ipr_pci_frozen(struct pci_dev *pdev)
9392 {
9393         unsigned long flags = 0;
9394         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9395
9396         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9397         if (ioa_cfg->probe_done)
9398                 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
9399         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9400 }
9401
9402 /**
9403  * ipr_pci_slot_reset - Called when PCI slot has been reset.
9404  * @pdev:       PCI device struct
9405  *
9406  * Description: This routine is called by the pci error recovery
9407  * code after the PCI slot has been reset, just before we
9408  * should resume normal operations.
9409  */
9410 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
9411 {
9412         unsigned long flags = 0;
9413         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9414
9415         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9416         if (ioa_cfg->probe_done) {
9417                 if (ioa_cfg->needs_warm_reset)
9418                         ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9419                 else
9420                         _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
9421                                                 IPR_SHUTDOWN_NONE);
9422         } else
9423                 wake_up_all(&ioa_cfg->eeh_wait_q);
9424         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9425         return PCI_ERS_RESULT_RECOVERED;
9426 }
9427
9428 /**
9429  * ipr_pci_perm_failure - Called when PCI slot is dead for good.
9430  * @pdev:       PCI device struct
9431  *
9432  * Description: This routine is called when the PCI bus has
9433  * permanently failed.
9434  */
9435 static void ipr_pci_perm_failure(struct pci_dev *pdev)
9436 {
9437         unsigned long flags = 0;
9438         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
9439         int i;
9440
9441         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
9442         if (ioa_cfg->probe_done) {
9443                 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
9444                         ioa_cfg->sdt_state = ABORT_DUMP;
9445                 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
9446                 ioa_cfg->in_ioa_bringdown = 1;
9447                 for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9448                         spin_lock(&ioa_cfg->hrrq[i]._lock);
9449                         ioa_cfg->hrrq[i].allow_cmds = 0;
9450                         spin_unlock(&ioa_cfg->hrrq[i]._lock);
9451                 }
9452                 wmb();
9453                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9454         } else
9455                 wake_up_all(&ioa_cfg->eeh_wait_q);
9456         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
9457 }
9458
9459 /**
9460  * ipr_pci_error_detected - Called when a PCI error is detected.
9461  * @pdev:       PCI device struct
9462  * @state:      PCI channel state
9463  *
9464  * Description: Called when a PCI error is detected.
9465  *
9466  * Return value:
9467  *      PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
9468  */
9469 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
9470                                                pci_channel_state_t state)
9471 {
9472         switch (state) {
9473         case pci_channel_io_frozen:
9474                 ipr_pci_frozen(pdev);
9475                 return PCI_ERS_RESULT_CAN_RECOVER;
9476         case pci_channel_io_perm_failure:
9477                 ipr_pci_perm_failure(pdev);
9478                 return PCI_ERS_RESULT_DISCONNECT;
9479                 break;
9480         default:
9481                 break;
9482         }
9483         return PCI_ERS_RESULT_NEED_RESET;
9484 }
9485
9486 /**
9487  * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
9488  * @ioa_cfg:    ioa cfg struct
9489  *
9490  * Description: This is the second phase of adapter initialization
9491  * This function takes care of initilizing the adapter to the point
9492  * where it can accept new commands.
9493
9494  * Return value:
9495  *      0 on success / -EIO on failure
9496  **/
9497 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
9498 {
9499         int rc = 0;
9500         unsigned long host_lock_flags = 0;
9501
9502         ENTER;
9503         spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
9504         dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
9505         ioa_cfg->probe_done = 1;
9506         if (ioa_cfg->needs_hard_reset) {
9507                 ioa_cfg->needs_hard_reset = 0;
9508                 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
9509         } else
9510                 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
9511                                         IPR_SHUTDOWN_NONE);
9512         spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
9513
9514         LEAVE;
9515         return rc;
9516 }
9517
9518 /**
9519  * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
9520  * @ioa_cfg:    ioa config struct
9521  *
9522  * Return value:
9523  *      none
9524  **/
9525 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9526 {
9527         int i;
9528
9529         if (ioa_cfg->ipr_cmnd_list) {
9530                 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9531                         if (ioa_cfg->ipr_cmnd_list[i])
9532                                 dma_pool_free(ioa_cfg->ipr_cmd_pool,
9533                                               ioa_cfg->ipr_cmnd_list[i],
9534                                               ioa_cfg->ipr_cmnd_list_dma[i]);
9535
9536                         ioa_cfg->ipr_cmnd_list[i] = NULL;
9537                 }
9538         }
9539
9540         if (ioa_cfg->ipr_cmd_pool)
9541                 dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
9542
9543         kfree(ioa_cfg->ipr_cmnd_list);
9544         kfree(ioa_cfg->ipr_cmnd_list_dma);
9545         ioa_cfg->ipr_cmnd_list = NULL;
9546         ioa_cfg->ipr_cmnd_list_dma = NULL;
9547         ioa_cfg->ipr_cmd_pool = NULL;
9548 }
9549
9550 /**
9551  * ipr_free_mem - Frees memory allocated for an adapter
9552  * @ioa_cfg:    ioa cfg struct
9553  *
9554  * Return value:
9555  *      nothing
9556  **/
9557 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
9558 {
9559         int i;
9560
9561         kfree(ioa_cfg->res_entries);
9562         dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
9563                           ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9564         ipr_free_cmd_blks(ioa_cfg);
9565
9566         for (i = 0; i < ioa_cfg->hrrq_num; i++)
9567                 dma_free_coherent(&ioa_cfg->pdev->dev,
9568                                   sizeof(u32) * ioa_cfg->hrrq[i].size,
9569                                   ioa_cfg->hrrq[i].host_rrq,
9570                                   ioa_cfg->hrrq[i].host_rrq_dma);
9571
9572         dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
9573                           ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9574
9575         for (i = 0; i < IPR_MAX_HCAMS; i++) {
9576                 dma_free_coherent(&ioa_cfg->pdev->dev,
9577                                   sizeof(struct ipr_hostrcb),
9578                                   ioa_cfg->hostrcb[i],
9579                                   ioa_cfg->hostrcb_dma[i]);
9580         }
9581
9582         ipr_free_dump(ioa_cfg);
9583         kfree(ioa_cfg->trace);
9584 }
9585
9586 /**
9587  * ipr_free_irqs - Free all allocated IRQs for the adapter.
9588  * @ioa_cfg:    ipr cfg struct
9589  *
9590  * This function frees all allocated IRQs for the
9591  * specified adapter.
9592  *
9593  * Return value:
9594  *      none
9595  **/
9596 static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg)
9597 {
9598         struct pci_dev *pdev = ioa_cfg->pdev;
9599         int i;
9600
9601         for (i = 0; i < ioa_cfg->nvectors; i++)
9602                 free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]);
9603         pci_free_irq_vectors(pdev);
9604 }
9605
9606 /**
9607  * ipr_free_all_resources - Free all allocated resources for an adapter.
9608  * @ipr_cmd:    ipr command struct
9609  *
9610  * This function frees all allocated resources for the
9611  * specified adapter.
9612  *
9613  * Return value:
9614  *      none
9615  **/
9616 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
9617 {
9618         struct pci_dev *pdev = ioa_cfg->pdev;
9619
9620         ENTER;
9621         ipr_free_irqs(ioa_cfg);
9622         if (ioa_cfg->reset_work_q)
9623                 destroy_workqueue(ioa_cfg->reset_work_q);
9624         iounmap(ioa_cfg->hdw_dma_regs);
9625         pci_release_regions(pdev);
9626         ipr_free_mem(ioa_cfg);
9627         scsi_host_put(ioa_cfg->host);
9628         pci_disable_device(pdev);
9629         LEAVE;
9630 }
9631
9632 /**
9633  * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
9634  * @ioa_cfg:    ioa config struct
9635  *
9636  * Return value:
9637  *      0 on success / -ENOMEM on allocation failure
9638  **/
9639 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
9640 {
9641         struct ipr_cmnd *ipr_cmd;
9642         struct ipr_ioarcb *ioarcb;
9643         dma_addr_t dma_addr;
9644         int i, entries_each_hrrq, hrrq_id = 0;
9645
9646         ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
9647                                                 sizeof(struct ipr_cmnd), 512, 0);
9648
9649         if (!ioa_cfg->ipr_cmd_pool)
9650                 return -ENOMEM;
9651
9652         ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL);
9653         ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL);
9654
9655         if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
9656                 ipr_free_cmd_blks(ioa_cfg);
9657                 return -ENOMEM;
9658         }
9659
9660         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9661                 if (ioa_cfg->hrrq_num > 1) {
9662                         if (i == 0) {
9663                                 entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS;
9664                                 ioa_cfg->hrrq[i].min_cmd_id = 0;
9665                                 ioa_cfg->hrrq[i].max_cmd_id =
9666                                         (entries_each_hrrq - 1);
9667                         } else {
9668                                 entries_each_hrrq =
9669                                         IPR_NUM_BASE_CMD_BLKS/
9670                                         (ioa_cfg->hrrq_num - 1);
9671                                 ioa_cfg->hrrq[i].min_cmd_id =
9672                                         IPR_NUM_INTERNAL_CMD_BLKS +
9673                                         (i - 1) * entries_each_hrrq;
9674                                 ioa_cfg->hrrq[i].max_cmd_id =
9675                                         (IPR_NUM_INTERNAL_CMD_BLKS +
9676                                         i * entries_each_hrrq - 1);
9677                         }
9678                 } else {
9679                         entries_each_hrrq = IPR_NUM_CMD_BLKS;
9680                         ioa_cfg->hrrq[i].min_cmd_id = 0;
9681                         ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1);
9682                 }
9683                 ioa_cfg->hrrq[i].size = entries_each_hrrq;
9684         }
9685
9686         BUG_ON(ioa_cfg->hrrq_num == 0);
9687
9688         i = IPR_NUM_CMD_BLKS -
9689                 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1;
9690         if (i > 0) {
9691                 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i;
9692                 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i;
9693         }
9694
9695         for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
9696                 ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool,
9697                                 GFP_KERNEL, &dma_addr);
9698
9699                 if (!ipr_cmd) {
9700                         ipr_free_cmd_blks(ioa_cfg);
9701                         return -ENOMEM;
9702                 }
9703
9704                 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
9705                 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
9706
9707                 ioarcb = &ipr_cmd->ioarcb;
9708                 ipr_cmd->dma_addr = dma_addr;
9709                 if (ioa_cfg->sis64)
9710                         ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
9711                 else
9712                         ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
9713
9714                 ioarcb->host_response_handle = cpu_to_be32(i << 2);
9715                 if (ioa_cfg->sis64) {
9716                         ioarcb->u.sis64_addr_data.data_ioadl_addr =
9717                                 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
9718                         ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
9719                                 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
9720                 } else {
9721                         ioarcb->write_ioadl_addr =
9722                                 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
9723                         ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
9724                         ioarcb->ioasa_host_pci_addr =
9725                                 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
9726                 }
9727                 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
9728                 ipr_cmd->cmd_index = i;
9729                 ipr_cmd->ioa_cfg = ioa_cfg;
9730                 ipr_cmd->sense_buffer_dma = dma_addr +
9731                         offsetof(struct ipr_cmnd, sense_buffer);
9732
9733                 ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id;
9734                 ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id];
9735                 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
9736                 if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id)
9737                         hrrq_id++;
9738         }
9739
9740         return 0;
9741 }
9742
9743 /**
9744  * ipr_alloc_mem - Allocate memory for an adapter
9745  * @ioa_cfg:    ioa config struct
9746  *
9747  * Return value:
9748  *      0 on success / non-zero for error
9749  **/
9750 static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
9751 {
9752         struct pci_dev *pdev = ioa_cfg->pdev;
9753         int i, rc = -ENOMEM;
9754
9755         ENTER;
9756         ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported,
9757                                        sizeof(struct ipr_resource_entry),
9758                                        GFP_KERNEL);
9759
9760         if (!ioa_cfg->res_entries)
9761                 goto out;
9762
9763         for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
9764                 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
9765                 ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
9766         }
9767
9768         ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
9769                                               sizeof(struct ipr_misc_cbs),
9770                                               &ioa_cfg->vpd_cbs_dma,
9771                                               GFP_KERNEL);
9772
9773         if (!ioa_cfg->vpd_cbs)
9774                 goto out_free_res_entries;
9775
9776         if (ipr_alloc_cmd_blks(ioa_cfg))
9777                 goto out_free_vpd_cbs;
9778
9779         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9780                 ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
9781                                         sizeof(u32) * ioa_cfg->hrrq[i].size,
9782                                         &ioa_cfg->hrrq[i].host_rrq_dma,
9783                                         GFP_KERNEL);
9784
9785                 if (!ioa_cfg->hrrq[i].host_rrq)  {
9786                         while (--i > 0)
9787                                 dma_free_coherent(&pdev->dev,
9788                                         sizeof(u32) * ioa_cfg->hrrq[i].size,
9789                                         ioa_cfg->hrrq[i].host_rrq,
9790                                         ioa_cfg->hrrq[i].host_rrq_dma);
9791                         goto out_ipr_free_cmd_blocks;
9792                 }
9793                 ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
9794         }
9795
9796         ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
9797                                                   ioa_cfg->cfg_table_size,
9798                                                   &ioa_cfg->cfg_table_dma,
9799                                                   GFP_KERNEL);
9800
9801         if (!ioa_cfg->u.cfg_table)
9802                 goto out_free_host_rrq;
9803
9804         for (i = 0; i < IPR_MAX_HCAMS; i++) {
9805                 ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
9806                                                          sizeof(struct ipr_hostrcb),
9807                                                          &ioa_cfg->hostrcb_dma[i],
9808                                                          GFP_KERNEL);
9809
9810                 if (!ioa_cfg->hostrcb[i])
9811                         goto out_free_hostrcb_dma;
9812
9813                 ioa_cfg->hostrcb[i]->hostrcb_dma =
9814                         ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
9815                 ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
9816                 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
9817         }
9818
9819         ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES,
9820                                  sizeof(struct ipr_trace_entry),
9821                                  GFP_KERNEL);
9822
9823         if (!ioa_cfg->trace)
9824                 goto out_free_hostrcb_dma;
9825
9826         rc = 0;
9827 out:
9828         LEAVE;
9829         return rc;
9830
9831 out_free_hostrcb_dma:
9832         while (i-- > 0) {
9833                 dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
9834                                   ioa_cfg->hostrcb[i],
9835                                   ioa_cfg->hostrcb_dma[i]);
9836         }
9837         dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
9838                           ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
9839 out_free_host_rrq:
9840         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
9841                 dma_free_coherent(&pdev->dev,
9842                                   sizeof(u32) * ioa_cfg->hrrq[i].size,
9843                                   ioa_cfg->hrrq[i].host_rrq,
9844                                   ioa_cfg->hrrq[i].host_rrq_dma);
9845         }
9846 out_ipr_free_cmd_blocks:
9847         ipr_free_cmd_blks(ioa_cfg);
9848 out_free_vpd_cbs:
9849         dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
9850                           ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
9851 out_free_res_entries:
9852         kfree(ioa_cfg->res_entries);
9853         goto out;
9854 }
9855
9856 /**
9857  * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
9858  * @ioa_cfg:    ioa config struct
9859  *
9860  * Return value:
9861  *      none
9862  **/
9863 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
9864 {
9865         int i;
9866
9867         for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
9868                 ioa_cfg->bus_attr[i].bus = i;
9869                 ioa_cfg->bus_attr[i].qas_enabled = 0;
9870                 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
9871                 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
9872                         ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
9873                 else
9874                         ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
9875         }
9876 }
9877
9878 /**
9879  * ipr_init_regs - Initialize IOA registers
9880  * @ioa_cfg:    ioa config struct
9881  *
9882  * Return value:
9883  *      none
9884  **/
9885 static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg)
9886 {
9887         const struct ipr_interrupt_offsets *p;
9888         struct ipr_interrupts *t;
9889         void __iomem *base;
9890
9891         p = &ioa_cfg->chip_cfg->regs;
9892         t = &ioa_cfg->regs;
9893         base = ioa_cfg->hdw_dma_regs;
9894
9895         t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
9896         t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
9897         t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
9898         t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
9899         t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
9900         t->clr_interrupt_reg = base + p->clr_interrupt_reg;
9901         t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
9902         t->sense_interrupt_reg = base + p->sense_interrupt_reg;
9903         t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
9904         t->ioarrin_reg = base + p->ioarrin_reg;
9905         t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
9906         t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
9907         t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
9908         t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
9909         t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
9910         t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
9911
9912         if (ioa_cfg->sis64) {
9913                 t->init_feedback_reg = base + p->init_feedback_reg;
9914                 t->dump_addr_reg = base + p->dump_addr_reg;
9915                 t->dump_data_reg = base + p->dump_data_reg;
9916                 t->endian_swap_reg = base + p->endian_swap_reg;
9917         }
9918 }
9919
9920 /**
9921  * ipr_init_ioa_cfg - Initialize IOA config struct
9922  * @ioa_cfg:    ioa config struct
9923  * @host:               scsi host struct
9924  * @pdev:               PCI dev struct
9925  *
9926  * Return value:
9927  *      none
9928  **/
9929 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
9930                              struct Scsi_Host *host, struct pci_dev *pdev)
9931 {
9932         int i;
9933
9934         ioa_cfg->host = host;
9935         ioa_cfg->pdev = pdev;
9936         ioa_cfg->log_level = ipr_log_level;
9937         ioa_cfg->doorbell = IPR_DOORBELL;
9938         sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
9939         sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
9940         sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
9941         sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
9942         sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
9943         sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
9944
9945         INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
9946         INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
9947         INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q);
9948         INIT_LIST_HEAD(&ioa_cfg->free_res_q);
9949         INIT_LIST_HEAD(&ioa_cfg->used_res_q);
9950         INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
9951         INIT_WORK(&ioa_cfg->scsi_add_work_q, ipr_add_remove_thread);
9952         init_waitqueue_head(&ioa_cfg->reset_wait_q);
9953         init_waitqueue_head(&ioa_cfg->msi_wait_q);
9954         init_waitqueue_head(&ioa_cfg->eeh_wait_q);
9955         ioa_cfg->sdt_state = INACTIVE;
9956
9957         ipr_initialize_bus_attr(ioa_cfg);
9958         ioa_cfg->max_devs_supported = ipr_max_devs;
9959
9960         if (ioa_cfg->sis64) {
9961                 host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
9962                 host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
9963                 if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
9964                         ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
9965                 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
9966                                            + ((sizeof(struct ipr_config_table_entry64)
9967                                                * ioa_cfg->max_devs_supported)));
9968         } else {
9969                 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
9970                 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
9971                 if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
9972                         ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
9973                 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
9974                                            + ((sizeof(struct ipr_config_table_entry)
9975                                                * ioa_cfg->max_devs_supported)));
9976         }
9977
9978         host->max_channel = IPR_VSET_BUS;
9979         host->unique_id = host->host_no;
9980         host->max_cmd_len = IPR_MAX_CDB_LEN;
9981         host->can_queue = ioa_cfg->max_cmds;
9982         pci_set_drvdata(pdev, ioa_cfg);
9983
9984         for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) {
9985                 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q);
9986                 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q);
9987                 spin_lock_init(&ioa_cfg->hrrq[i]._lock);
9988                 if (i == 0)
9989                         ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock;
9990                 else
9991                         ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock;
9992         }
9993 }
9994
9995 /**
9996  * ipr_get_chip_info - Find adapter chip information
9997  * @dev_id:             PCI device id struct
9998  *
9999  * Return value:
10000  *      ptr to chip information on success / NULL on failure
10001  **/
10002 static const struct ipr_chip_t *
10003 ipr_get_chip_info(const struct pci_device_id *dev_id)
10004 {
10005         int i;
10006
10007         for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
10008                 if (ipr_chip[i].vendor == dev_id->vendor &&
10009                     ipr_chip[i].device == dev_id->device)
10010                         return &ipr_chip[i];
10011         return NULL;
10012 }
10013
10014 /**
10015  * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
10016  *                                              during probe time
10017  * @ioa_cfg:    ioa config struct
10018  *
10019  * Return value:
10020  *      None
10021  **/
10022 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg)
10023 {
10024         struct pci_dev *pdev = ioa_cfg->pdev;
10025
10026         if (pci_channel_offline(pdev)) {
10027                 wait_event_timeout(ioa_cfg->eeh_wait_q,
10028                                    !pci_channel_offline(pdev),
10029                                    IPR_PCI_ERROR_RECOVERY_TIMEOUT);
10030                 pci_restore_state(pdev);
10031         }
10032 }
10033
10034 static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg)
10035 {
10036         int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1;
10037
10038         for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) {
10039                 snprintf(ioa_cfg->vectors_info[vec_idx].desc, n,
10040                          "host%d-%d", ioa_cfg->host->host_no, vec_idx);
10041                 ioa_cfg->vectors_info[vec_idx].
10042                         desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0;
10043         }
10044 }
10045
10046 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg,
10047                 struct pci_dev *pdev)
10048 {
10049         int i, rc;
10050
10051         for (i = 1; i < ioa_cfg->nvectors; i++) {
10052                 rc = request_irq(pci_irq_vector(pdev, i),
10053                         ipr_isr_mhrrq,
10054                         0,
10055                         ioa_cfg->vectors_info[i].desc,
10056                         &ioa_cfg->hrrq[i]);
10057                 if (rc) {
10058                         while (--i >= 0)
10059                                 free_irq(pci_irq_vector(pdev, i),
10060                                         &ioa_cfg->hrrq[i]);
10061                         return rc;
10062                 }
10063         }
10064         return 0;
10065 }
10066
10067 /**
10068  * ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
10069  * @pdev:               PCI device struct
10070  *
10071  * Description: Simply set the msi_received flag to 1 indicating that
10072  * Message Signaled Interrupts are supported.
10073  *
10074  * Return value:
10075  *      0 on success / non-zero on failure
10076  **/
10077 static irqreturn_t ipr_test_intr(int irq, void *devp)
10078 {
10079         struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
10080         unsigned long lock_flags = 0;
10081         irqreturn_t rc = IRQ_HANDLED;
10082
10083         dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq);
10084         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10085
10086         ioa_cfg->msi_received = 1;
10087         wake_up(&ioa_cfg->msi_wait_q);
10088
10089         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10090         return rc;
10091 }
10092
10093 /**
10094  * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
10095  * @pdev:               PCI device struct
10096  *
10097  * Description: This routine sets up and initiates a test interrupt to determine
10098  * if the interrupt is received via the ipr_test_intr() service routine.
10099  * If the tests fails, the driver will fall back to LSI.
10100  *
10101  * Return value:
10102  *      0 on success / non-zero on failure
10103  **/
10104 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
10105 {
10106         int rc;
10107         volatile u32 int_reg;
10108         unsigned long lock_flags = 0;
10109         int irq = pci_irq_vector(pdev, 0);
10110
10111         ENTER;
10112
10113         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10114         init_waitqueue_head(&ioa_cfg->msi_wait_q);
10115         ioa_cfg->msi_received = 0;
10116         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10117         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
10118         int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
10119         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10120
10121         rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
10122         if (rc) {
10123                 dev_err(&pdev->dev, "Can not assign irq %d\n", irq);
10124                 return rc;
10125         } else if (ipr_debug)
10126                 dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
10127
10128         writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
10129         int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
10130         wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
10131         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10132         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10133
10134         if (!ioa_cfg->msi_received) {
10135                 /* MSI test failed */
10136                 dev_info(&pdev->dev, "MSI test failed.  Falling back to LSI.\n");
10137                 rc = -EOPNOTSUPP;
10138         } else if (ipr_debug)
10139                 dev_info(&pdev->dev, "MSI test succeeded.\n");
10140
10141         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10142
10143         free_irq(irq, ioa_cfg);
10144
10145         LEAVE;
10146
10147         return rc;
10148 }
10149
10150  /* ipr_probe_ioa - Allocates memory and does first stage of initialization
10151  * @pdev:               PCI device struct
10152  * @dev_id:             PCI device id struct
10153  *
10154  * Return value:
10155  *      0 on success / non-zero on failure
10156  **/
10157 static int ipr_probe_ioa(struct pci_dev *pdev,
10158                          const struct pci_device_id *dev_id)
10159 {
10160         struct ipr_ioa_cfg *ioa_cfg;
10161         struct Scsi_Host *host;
10162         unsigned long ipr_regs_pci;
10163         void __iomem *ipr_regs;
10164         int rc = PCIBIOS_SUCCESSFUL;
10165         volatile u32 mask, uproc, interrupts;
10166         unsigned long lock_flags, driver_lock_flags;
10167         unsigned int irq_flag;
10168
10169         ENTER;
10170
10171         dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
10172         host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
10173
10174         if (!host) {
10175                 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
10176                 rc = -ENOMEM;
10177                 goto out;
10178         }
10179
10180         ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
10181         memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
10182         ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops);
10183
10184         ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
10185
10186         if (!ioa_cfg->ipr_chip) {
10187                 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
10188                         dev_id->vendor, dev_id->device);
10189                 goto out_scsi_host_put;
10190         }
10191
10192         /* set SIS 32 or SIS 64 */
10193         ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
10194         ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
10195         ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr;
10196         ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds;
10197
10198         if (ipr_transop_timeout)
10199                 ioa_cfg->transop_timeout = ipr_transop_timeout;
10200         else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
10201                 ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
10202         else
10203                 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
10204
10205         ioa_cfg->revid = pdev->revision;
10206
10207         ipr_init_ioa_cfg(ioa_cfg, host, pdev);
10208
10209         ipr_regs_pci = pci_resource_start(pdev, 0);
10210
10211         rc = pci_request_regions(pdev, IPR_NAME);
10212         if (rc < 0) {
10213                 dev_err(&pdev->dev,
10214                         "Couldn't register memory range of registers\n");
10215                 goto out_scsi_host_put;
10216         }
10217
10218         rc = pci_enable_device(pdev);
10219
10220         if (rc || pci_channel_offline(pdev)) {
10221                 if (pci_channel_offline(pdev)) {
10222                         ipr_wait_for_pci_err_recovery(ioa_cfg);
10223                         rc = pci_enable_device(pdev);
10224                 }
10225
10226                 if (rc) {
10227                         dev_err(&pdev->dev, "Cannot enable adapter\n");
10228                         ipr_wait_for_pci_err_recovery(ioa_cfg);
10229                         goto out_release_regions;
10230                 }
10231         }
10232
10233         ipr_regs = pci_ioremap_bar(pdev, 0);
10234
10235         if (!ipr_regs) {
10236                 dev_err(&pdev->dev,
10237                         "Couldn't map memory range of registers\n");
10238                 rc = -ENOMEM;
10239                 goto out_disable;
10240         }
10241
10242         ioa_cfg->hdw_dma_regs = ipr_regs;
10243         ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
10244         ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
10245
10246         ipr_init_regs(ioa_cfg);
10247
10248         if (ioa_cfg->sis64) {
10249                 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
10250                 if (rc < 0) {
10251                         dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
10252                         rc = dma_set_mask_and_coherent(&pdev->dev,
10253                                                        DMA_BIT_MASK(32));
10254                 }
10255         } else
10256                 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
10257
10258         if (rc < 0) {
10259                 dev_err(&pdev->dev, "Failed to set DMA mask\n");
10260                 goto cleanup_nomem;
10261         }
10262
10263         rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
10264                                    ioa_cfg->chip_cfg->cache_line_size);
10265
10266         if (rc != PCIBIOS_SUCCESSFUL) {
10267                 dev_err(&pdev->dev, "Write of cache line size failed\n");
10268                 ipr_wait_for_pci_err_recovery(ioa_cfg);
10269                 rc = -EIO;
10270                 goto cleanup_nomem;
10271         }
10272
10273         /* Issue MMIO read to ensure card is not in EEH */
10274         interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
10275         ipr_wait_for_pci_err_recovery(ioa_cfg);
10276
10277         if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) {
10278                 dev_err(&pdev->dev, "The max number of MSIX is %d\n",
10279                         IPR_MAX_MSIX_VECTORS);
10280                 ipr_number_of_msix = IPR_MAX_MSIX_VECTORS;
10281         }
10282
10283         irq_flag = PCI_IRQ_LEGACY;
10284         if (ioa_cfg->ipr_chip->has_msi)
10285                 irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX;
10286         rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag);
10287         if (rc < 0) {
10288                 ipr_wait_for_pci_err_recovery(ioa_cfg);
10289                 goto cleanup_nomem;
10290         }
10291         ioa_cfg->nvectors = rc;
10292
10293         if (!pdev->msi_enabled && !pdev->msix_enabled)
10294                 ioa_cfg->clear_isr = 1;
10295
10296         pci_set_master(pdev);
10297
10298         if (pci_channel_offline(pdev)) {
10299                 ipr_wait_for_pci_err_recovery(ioa_cfg);
10300                 pci_set_master(pdev);
10301                 if (pci_channel_offline(pdev)) {
10302                         rc = -EIO;
10303                         goto out_msi_disable;
10304                 }
10305         }
10306
10307         if (pdev->msi_enabled || pdev->msix_enabled) {
10308                 rc = ipr_test_msi(ioa_cfg, pdev);
10309                 switch (rc) {
10310                 case 0:
10311                         dev_info(&pdev->dev,
10312                                 "Request for %d MSI%ss succeeded.", ioa_cfg->nvectors,
10313                                 pdev->msix_enabled ? "-X" : "");
10314                         break;
10315                 case -EOPNOTSUPP:
10316                         ipr_wait_for_pci_err_recovery(ioa_cfg);
10317                         pci_free_irq_vectors(pdev);
10318
10319                         ioa_cfg->nvectors = 1;
10320                         ioa_cfg->clear_isr = 1;
10321                         break;
10322                 default:
10323                         goto out_msi_disable;
10324                 }
10325         }
10326
10327         ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors,
10328                                 (unsigned int)num_online_cpus(),
10329                                 (unsigned int)IPR_MAX_HRRQ_NUM);
10330
10331         if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
10332                 goto out_msi_disable;
10333
10334         if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
10335                 goto out_msi_disable;
10336
10337         rc = ipr_alloc_mem(ioa_cfg);
10338         if (rc < 0) {
10339                 dev_err(&pdev->dev,
10340                         "Couldn't allocate enough memory for device driver!\n");
10341                 goto out_msi_disable;
10342         }
10343
10344         /* Save away PCI config space for use following IOA reset */
10345         rc = pci_save_state(pdev);
10346
10347         if (rc != PCIBIOS_SUCCESSFUL) {
10348                 dev_err(&pdev->dev, "Failed to save PCI config space\n");
10349                 rc = -EIO;
10350                 goto cleanup_nolog;
10351         }
10352
10353         /*
10354          * If HRRQ updated interrupt is not masked, or reset alert is set,
10355          * the card is in an unknown state and needs a hard reset
10356          */
10357         mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
10358         interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
10359         uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
10360         if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
10361                 ioa_cfg->needs_hard_reset = 1;
10362         if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices)
10363                 ioa_cfg->needs_hard_reset = 1;
10364         if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
10365                 ioa_cfg->ioa_unit_checked = 1;
10366
10367         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10368         ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
10369         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10370
10371         if (pdev->msi_enabled || pdev->msix_enabled) {
10372                 name_msi_vectors(ioa_cfg);
10373                 rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0,
10374                         ioa_cfg->vectors_info[0].desc,
10375                         &ioa_cfg->hrrq[0]);
10376                 if (!rc)
10377                         rc = ipr_request_other_msi_irqs(ioa_cfg, pdev);
10378         } else {
10379                 rc = request_irq(pdev->irq, ipr_isr,
10380                          IRQF_SHARED,
10381                          IPR_NAME, &ioa_cfg->hrrq[0]);
10382         }
10383         if (rc) {
10384                 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
10385                         pdev->irq, rc);
10386                 goto cleanup_nolog;
10387         }
10388
10389         if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
10390             (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
10391                 ioa_cfg->needs_warm_reset = 1;
10392                 ioa_cfg->reset = ipr_reset_slot_reset;
10393
10394                 ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d",
10395                                                                 WQ_MEM_RECLAIM, host->host_no);
10396
10397                 if (!ioa_cfg->reset_work_q) {
10398                         dev_err(&pdev->dev, "Couldn't register reset workqueue\n");
10399                         rc = -ENOMEM;
10400                         goto out_free_irq;
10401                 }
10402         } else
10403                 ioa_cfg->reset = ipr_reset_start_bist;
10404
10405         spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10406         list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
10407         spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10408
10409         LEAVE;
10410 out:
10411         return rc;
10412
10413 out_free_irq:
10414         ipr_free_irqs(ioa_cfg);
10415 cleanup_nolog:
10416         ipr_free_mem(ioa_cfg);
10417 out_msi_disable:
10418         ipr_wait_for_pci_err_recovery(ioa_cfg);
10419         pci_free_irq_vectors(pdev);
10420 cleanup_nomem:
10421         iounmap(ipr_regs);
10422 out_disable:
10423         pci_disable_device(pdev);
10424 out_release_regions:
10425         pci_release_regions(pdev);
10426 out_scsi_host_put:
10427         scsi_host_put(host);
10428         goto out;
10429 }
10430
10431 /**
10432  * ipr_initiate_ioa_bringdown - Bring down an adapter
10433  * @ioa_cfg:            ioa config struct
10434  * @shutdown_type:      shutdown type
10435  *
10436  * Description: This function will initiate bringing down the adapter.
10437  * This consists of issuing an IOA shutdown to the adapter
10438  * to flush the cache, and running BIST.
10439  * If the caller needs to wait on the completion of the reset,
10440  * the caller must sleep on the reset_wait_q.
10441  *
10442  * Return value:
10443  *      none
10444  **/
10445 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
10446                                        enum ipr_shutdown_type shutdown_type)
10447 {
10448         ENTER;
10449         if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
10450                 ioa_cfg->sdt_state = ABORT_DUMP;
10451         ioa_cfg->reset_retries = 0;
10452         ioa_cfg->in_ioa_bringdown = 1;
10453         ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
10454         LEAVE;
10455 }
10456
10457 /**
10458  * __ipr_remove - Remove a single adapter
10459  * @pdev:       pci device struct
10460  *
10461  * Adapter hot plug remove entry point.
10462  *
10463  * Return value:
10464  *      none
10465  **/
10466 static void __ipr_remove(struct pci_dev *pdev)
10467 {
10468         unsigned long host_lock_flags = 0;
10469         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10470         int i;
10471         unsigned long driver_lock_flags;
10472         ENTER;
10473
10474         spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10475         while (ioa_cfg->in_reset_reload) {
10476                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10477                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10478                 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10479         }
10480
10481         for (i = 0; i < ioa_cfg->hrrq_num; i++) {
10482                 spin_lock(&ioa_cfg->hrrq[i]._lock);
10483                 ioa_cfg->hrrq[i].removing_ioa = 1;
10484                 spin_unlock(&ioa_cfg->hrrq[i]._lock);
10485         }
10486         wmb();
10487         ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
10488
10489         spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10490         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10491         flush_work(&ioa_cfg->work_q);
10492         if (ioa_cfg->reset_work_q)
10493                 flush_workqueue(ioa_cfg->reset_work_q);
10494         INIT_LIST_HEAD(&ioa_cfg->used_res_q);
10495         spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
10496
10497         spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10498         list_del(&ioa_cfg->queue);
10499         spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10500
10501         if (ioa_cfg->sdt_state == ABORT_DUMP)
10502                 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
10503         spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
10504
10505         ipr_free_all_resources(ioa_cfg);
10506
10507         LEAVE;
10508 }
10509
10510 /**
10511  * ipr_remove - IOA hot plug remove entry point
10512  * @pdev:       pci device struct
10513  *
10514  * Adapter hot plug remove entry point.
10515  *
10516  * Return value:
10517  *      none
10518  **/
10519 static void ipr_remove(struct pci_dev *pdev)
10520 {
10521         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10522
10523         ENTER;
10524
10525         ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10526                               &ipr_trace_attr);
10527         ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10528                              &ipr_dump_attr);
10529         sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10530                         &ipr_ioa_async_err_log);
10531         scsi_remove_host(ioa_cfg->host);
10532
10533         __ipr_remove(pdev);
10534
10535         LEAVE;
10536 }
10537
10538 /**
10539  * ipr_probe - Adapter hot plug add entry point
10540  *
10541  * Return value:
10542  *      0 on success / non-zero on failure
10543  **/
10544 static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
10545 {
10546         struct ipr_ioa_cfg *ioa_cfg;
10547         unsigned long flags;
10548         int rc, i;
10549
10550         rc = ipr_probe_ioa(pdev, dev_id);
10551
10552         if (rc)
10553                 return rc;
10554
10555         ioa_cfg = pci_get_drvdata(pdev);
10556         rc = ipr_probe_ioa_part2(ioa_cfg);
10557
10558         if (rc) {
10559                 __ipr_remove(pdev);
10560                 return rc;
10561         }
10562
10563         rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
10564
10565         if (rc) {
10566                 __ipr_remove(pdev);
10567                 return rc;
10568         }
10569
10570         rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
10571                                    &ipr_trace_attr);
10572
10573         if (rc) {
10574                 scsi_remove_host(ioa_cfg->host);
10575                 __ipr_remove(pdev);
10576                 return rc;
10577         }
10578
10579         rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj,
10580                         &ipr_ioa_async_err_log);
10581
10582         if (rc) {
10583                 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
10584                                 &ipr_dump_attr);
10585                 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10586                                 &ipr_trace_attr);
10587                 scsi_remove_host(ioa_cfg->host);
10588                 __ipr_remove(pdev);
10589                 return rc;
10590         }
10591
10592         rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
10593                                    &ipr_dump_attr);
10594
10595         if (rc) {
10596                 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
10597                                       &ipr_ioa_async_err_log);
10598                 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
10599                                       &ipr_trace_attr);
10600                 scsi_remove_host(ioa_cfg->host);
10601                 __ipr_remove(pdev);
10602                 return rc;
10603         }
10604         spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10605         ioa_cfg->scan_enabled = 1;
10606         schedule_work(&ioa_cfg->work_q);
10607         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10608
10609         ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight;
10610
10611         if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10612                 for (i = 1; i < ioa_cfg->hrrq_num; i++) {
10613                         irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
10614                                         ioa_cfg->iopoll_weight, ipr_iopoll);
10615                 }
10616         }
10617
10618         scsi_scan_host(ioa_cfg->host);
10619
10620         return 0;
10621 }
10622
10623 /**
10624  * ipr_shutdown - Shutdown handler.
10625  * @pdev:       pci device struct
10626  *
10627  * This function is invoked upon system shutdown/reboot. It will issue
10628  * an adapter shutdown to the adapter to flush the write cache.
10629  *
10630  * Return value:
10631  *      none
10632  **/
10633 static void ipr_shutdown(struct pci_dev *pdev)
10634 {
10635         struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
10636         unsigned long lock_flags = 0;
10637         enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL;
10638         int i;
10639
10640         spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10641         if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
10642                 ioa_cfg->iopoll_weight = 0;
10643                 for (i = 1; i < ioa_cfg->hrrq_num; i++)
10644                         irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
10645         }
10646
10647         while (ioa_cfg->in_reset_reload) {
10648                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10649                 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10650                 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
10651         }
10652
10653         if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64)
10654                 shutdown_type = IPR_SHUTDOWN_QUIESCE;
10655
10656         ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type);
10657         spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
10658         wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
10659         if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) {
10660                 ipr_free_irqs(ioa_cfg);
10661                 pci_disable_device(ioa_cfg->pdev);
10662         }
10663 }
10664
10665 static struct pci_device_id ipr_pci_table[] = {
10666         { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10667                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
10668         { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10669                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
10670         { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10671                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
10672         { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
10673                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
10674         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10675                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
10676         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10677                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
10678         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10679                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
10680         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
10681                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
10682                 IPR_USE_LONG_TRANSOP_TIMEOUT },
10683         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10684               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10685         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10686               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10687               IPR_USE_LONG_TRANSOP_TIMEOUT },
10688         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
10689               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10690               IPR_USE_LONG_TRANSOP_TIMEOUT },
10691         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10692               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
10693         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10694               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
10695               IPR_USE_LONG_TRANSOP_TIMEOUT},
10696         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
10697               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
10698               IPR_USE_LONG_TRANSOP_TIMEOUT },
10699         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10700               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
10701               IPR_USE_LONG_TRANSOP_TIMEOUT },
10702         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10703               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
10704         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10705               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 },
10706         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
10707               PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
10708               IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
10709         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
10710                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
10711         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10712                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
10713         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10714                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
10715                 IPR_USE_LONG_TRANSOP_TIMEOUT },
10716         { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
10717                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
10718                 IPR_USE_LONG_TRANSOP_TIMEOUT },
10719         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10720                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
10721         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10722                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
10723         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10724                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
10725         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10726                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 },
10727         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10728                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 },
10729         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
10730                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 },
10731         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10732                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
10733         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10734                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
10735         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10736                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
10737         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10738                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 },
10739         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10740                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
10741         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10742                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 },
10743         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10744                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 },
10745         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10746                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 },
10747         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10748                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 },
10749         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10750                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 },
10751         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10752                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 },
10753         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10754                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 },
10755         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10756                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 },
10757         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10758                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 },
10759         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10760                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 },
10761         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10762                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 },
10763         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10764                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 },
10765         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10766                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 },
10767         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10768                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 },
10769         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
10770                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 },
10771         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10772                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 },
10773         { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
10774                 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 },
10775         { }
10776 };
10777 MODULE_DEVICE_TABLE(pci, ipr_pci_table);
10778
10779 static const struct pci_error_handlers ipr_err_handler = {
10780         .error_detected = ipr_pci_error_detected,
10781         .mmio_enabled = ipr_pci_mmio_enabled,
10782         .slot_reset = ipr_pci_slot_reset,
10783 };
10784
10785 static struct pci_driver ipr_driver = {
10786         .name = IPR_NAME,
10787         .id_table = ipr_pci_table,
10788         .probe = ipr_probe,
10789         .remove = ipr_remove,
10790         .shutdown = ipr_shutdown,
10791         .err_handler = &ipr_err_handler,
10792 };
10793
10794 /**
10795  * ipr_halt_done - Shutdown prepare completion
10796  *
10797  * Return value:
10798  *      none
10799  **/
10800 static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
10801 {
10802         list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
10803 }
10804
10805 /**
10806  * ipr_halt - Issue shutdown prepare to all adapters
10807  *
10808  * Return value:
10809  *      NOTIFY_OK on success / NOTIFY_DONE on failure
10810  **/
10811 static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
10812 {
10813         struct ipr_cmnd *ipr_cmd;
10814         struct ipr_ioa_cfg *ioa_cfg;
10815         unsigned long flags = 0, driver_lock_flags;
10816
10817         if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
10818                 return NOTIFY_DONE;
10819
10820         spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
10821
10822         list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
10823                 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
10824                 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
10825                     (ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) {
10826                         spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10827                         continue;
10828                 }
10829
10830                 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
10831                 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
10832                 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
10833                 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
10834                 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
10835
10836                 ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
10837                 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
10838         }
10839         spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
10840
10841         return NOTIFY_OK;
10842 }
10843
10844 static struct notifier_block ipr_notifier = {
10845         ipr_halt, NULL, 0
10846 };
10847
10848 /**
10849  * ipr_init - Module entry point
10850  *
10851  * Return value:
10852  *      0 on success / negative value on failure
10853  **/
10854 static int __init ipr_init(void)
10855 {
10856         ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
10857                  IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
10858
10859         register_reboot_notifier(&ipr_notifier);
10860         return pci_register_driver(&ipr_driver);
10861 }
10862
10863 /**
10864  * ipr_exit - Module unload
10865  *
10866  * Module unload entry point.
10867  *
10868  * Return value:
10869  *      none
10870  **/
10871 static void __exit ipr_exit(void)
10872 {
10873         unregister_reboot_notifier(&ipr_notifier);
10874         pci_unregister_driver(&ipr_driver);
10875 }
10876
10877 module_init(ipr_init);
10878 module_exit(ipr_exit);