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