drivers/scsi/ipr.c

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