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