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