linux/drivers/scsi/ipr.c
<<
>>
Prefs
   1/*
   2 * ipr.c -- driver for IBM Power Linux RAID adapters
   3 *
   4 * Written By: Brian King <brking@us.ibm.com>, IBM Corporation
   5 *
   6 * Copyright (C) 2003, 2004 IBM Corporation
   7 *
   8 * This program is free software; you can redistribute it and/or modify
   9 * it under the terms of the GNU General Public License as published by
  10 * the Free Software Foundation; either version 2 of the License, or
  11 * (at your option) any later version.
  12 *
  13 * This program is distributed in the hope that it will be useful,
  14 * but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 * GNU General Public License for more details.
  17 *
  18 * You should have received a copy of the GNU General Public License
  19 * along with this program; if not, write to the Free Software
  20 * Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA
  21 *
  22 */
  23
  24/*
  25 * Notes:
  26 *
  27 * This driver is used to control the following SCSI adapters:
  28 *
  29 * IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
  30 *
  31 * IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
  32 *              PCI-X Dual Channel Ultra 320 SCSI Adapter
  33 *              PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
  34 *              Embedded SCSI adapter on p615 and p655 systems
  35 *
  36 * Supported Hardware Features:
  37 *      - Ultra 320 SCSI controller
  38 *      - PCI-X host interface
  39 *      - Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
  40 *      - Non-Volatile Write Cache
  41 *      - Supports attachment of non-RAID disks, tape, and optical devices
  42 *      - RAID Levels 0, 5, 10
  43 *      - Hot spare
  44 *      - Background Parity Checking
  45 *      - Background Data Scrubbing
  46 *      - Ability to increase the capacity of an existing RAID 5 disk array
  47 *              by adding disks
  48 *
  49 * Driver Features:
  50 *      - Tagged command queuing
  51 *      - Adapter microcode download
  52 *      - PCI hot plug
  53 *      - SCSI device hot plug
  54 *
  55 */
  56
  57#include <linux/fs.h>
  58#include <linux/init.h>
  59#include <linux/types.h>
  60#include <linux/errno.h>
  61#include <linux/kernel.h>
  62#include <linux/slab.h>
  63#include <linux/vmalloc.h>
  64#include <linux/ioport.h>
  65#include <linux/delay.h>
  66#include <linux/pci.h>
  67#include <linux/wait.h>
  68#include <linux/spinlock.h>
  69#include <linux/sched.h>
  70#include <linux/interrupt.h>
  71#include <linux/blkdev.h>
  72#include <linux/firmware.h>
  73#include <linux/module.h>
  74#include <linux/moduleparam.h>
  75#include <linux/libata.h>
  76#include <linux/hdreg.h>
  77#include <linux/reboot.h>
  78#include <linux/stringify.h>
  79#include <asm/io.h>
  80#include <asm/irq.h>
  81#include <asm/processor.h>
  82#include <scsi/scsi.h>
  83#include <scsi/scsi_host.h>
  84#include <scsi/scsi_tcq.h>
  85#include <scsi/scsi_eh.h>
  86#include <scsi/scsi_cmnd.h>
  87#include "ipr.h"
  88
  89/*
  90 *   Global Data
  91 */
  92static LIST_HEAD(ipr_ioa_head);
  93static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
  94static unsigned int ipr_max_speed = 1;
  95static int ipr_testmode = 0;
  96static unsigned int ipr_fastfail = 0;
  97static unsigned int ipr_transop_timeout = 0;
  98static unsigned int ipr_debug = 0;
  99static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
 100static unsigned int ipr_dual_ioa_raid = 1;
 101static unsigned int ipr_number_of_msix = 2;
 102static DEFINE_SPINLOCK(ipr_driver_lock);
 103
 104/* This table describes the differences between DMA controller chips */
 105static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
 106        { /* Gemstone, Citrine, Obsidian, and Obsidian-E */
 107                .mailbox = 0x0042C,
 108                .max_cmds = 100,
 109                .cache_line_size = 0x20,
 110                .clear_isr = 1,
 111                .iopoll_weight = 0,
 112                {
 113                        .set_interrupt_mask_reg = 0x0022C,
 114                        .clr_interrupt_mask_reg = 0x00230,
 115                        .clr_interrupt_mask_reg32 = 0x00230,
 116                        .sense_interrupt_mask_reg = 0x0022C,
 117                        .sense_interrupt_mask_reg32 = 0x0022C,
 118                        .clr_interrupt_reg = 0x00228,
 119                        .clr_interrupt_reg32 = 0x00228,
 120                        .sense_interrupt_reg = 0x00224,
 121                        .sense_interrupt_reg32 = 0x00224,
 122                        .ioarrin_reg = 0x00404,
 123                        .sense_uproc_interrupt_reg = 0x00214,
 124                        .sense_uproc_interrupt_reg32 = 0x00214,
 125                        .set_uproc_interrupt_reg = 0x00214,
 126                        .set_uproc_interrupt_reg32 = 0x00214,
 127                        .clr_uproc_interrupt_reg = 0x00218,
 128                        .clr_uproc_interrupt_reg32 = 0x00218
 129                }
 130        },
 131        { /* Snipe and Scamp */
 132                .mailbox = 0x0052C,
 133                .max_cmds = 100,
 134                .cache_line_size = 0x20,
 135                .clear_isr = 1,
 136                .iopoll_weight = 0,
 137                {
 138                        .set_interrupt_mask_reg = 0x00288,
 139                        .clr_interrupt_mask_reg = 0x0028C,
 140                        .clr_interrupt_mask_reg32 = 0x0028C,
 141                        .sense_interrupt_mask_reg = 0x00288,
 142                        .sense_interrupt_mask_reg32 = 0x00288,
 143                        .clr_interrupt_reg = 0x00284,
 144                        .clr_interrupt_reg32 = 0x00284,
 145                        .sense_interrupt_reg = 0x00280,
 146                        .sense_interrupt_reg32 = 0x00280,
 147                        .ioarrin_reg = 0x00504,
 148                        .sense_uproc_interrupt_reg = 0x00290,
 149                        .sense_uproc_interrupt_reg32 = 0x00290,
 150                        .set_uproc_interrupt_reg = 0x00290,
 151                        .set_uproc_interrupt_reg32 = 0x00290,
 152                        .clr_uproc_interrupt_reg = 0x00294,
 153                        .clr_uproc_interrupt_reg32 = 0x00294
 154                }
 155        },
 156        { /* CRoC */
 157                .mailbox = 0x00044,
 158                .max_cmds = 1000,
 159                .cache_line_size = 0x20,
 160                .clear_isr = 0,
 161                .iopoll_weight = 64,
 162                {
 163                        .set_interrupt_mask_reg = 0x00010,
 164                        .clr_interrupt_mask_reg = 0x00018,
 165                        .clr_interrupt_mask_reg32 = 0x0001C,
 166                        .sense_interrupt_mask_reg = 0x00010,
 167                        .sense_interrupt_mask_reg32 = 0x00014,
 168                        .clr_interrupt_reg = 0x00008,
 169                        .clr_interrupt_reg32 = 0x0000C,
 170                        .sense_interrupt_reg = 0x00000,
 171                        .sense_interrupt_reg32 = 0x00004,
 172                        .ioarrin_reg = 0x00070,
 173                        .sense_uproc_interrupt_reg = 0x00020,
 174                        .sense_uproc_interrupt_reg32 = 0x00024,
 175                        .set_uproc_interrupt_reg = 0x00020,
 176                        .set_uproc_interrupt_reg32 = 0x00024,
 177                        .clr_uproc_interrupt_reg = 0x00028,
 178                        .clr_uproc_interrupt_reg32 = 0x0002C,
 179                        .init_feedback_reg = 0x0005C,
 180                        .dump_addr_reg = 0x00064,
 181                        .dump_data_reg = 0x00068,
 182                        .endian_swap_reg = 0x00084
 183                }
 184        },
 185};
 186
 187static const struct ipr_chip_t ipr_chip[] = {
 188        { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 189        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 190        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 191        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 192        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 193        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
 194        { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
 195        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
 196        { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
 197};
 198
 199static int ipr_max_bus_speeds[] = {
 200        IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
 201};
 202
 203MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
 204MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
 205module_param_named(max_speed, ipr_max_speed, uint, 0);
 206MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
 207module_param_named(log_level, ipr_log_level, uint, 0);
 208MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
 209module_param_named(testmode, ipr_testmode, int, 0);
 210MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
 211module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
 212MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
 213module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
 214MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
 215module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
 216MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
 217module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
 218MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
 219module_param_named(max_devs, ipr_max_devs, int, 0);
 220MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
 221                 "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
 222module_param_named(number_of_msix, ipr_number_of_msix, int, 0);
 223MODULE_PARM_DESC(number_of_msix, "Specify the number of MSIX interrupts to use on capable adapters (1 - 5).  (default:2)");
 224MODULE_LICENSE("GPL");
 225MODULE_VERSION(IPR_DRIVER_VERSION);
 226
 227/*  A constant array of IOASCs/URCs/Error Messages */
 228static const
 229struct ipr_error_table_t ipr_error_table[] = {
 230        {0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
 231        "8155: An unknown error was received"},
 232        {0x00330000, 0, 0,
 233        "Soft underlength error"},
 234        {0x005A0000, 0, 0,
 235        "Command to be cancelled not found"},
 236        {0x00808000, 0, 0,
 237        "Qualified success"},
 238        {0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
 239        "FFFE: Soft device bus error recovered by the IOA"},
 240        {0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
 241        "4101: Soft device bus fabric error"},
 242        {0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
 243        "FFFC: Logical block guard error recovered by the device"},
 244        {0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
 245        "FFFC: Logical block reference tag error recovered by the device"},
 246        {0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
 247        "4171: Recovered scatter list tag / sequence number error"},
 248        {0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
 249        "FF3D: Recovered logical block CRC error on IOA to Host transfer"},
 250        {0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
 251        "4171: Recovered logical block sequence number error on IOA to Host transfer"},
 252        {0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
 253        "FFFD: Recovered logical block reference tag error detected by the IOA"},
 254        {0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
 255        "FFFD: Logical block guard error recovered by the IOA"},
 256        {0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
 257        "FFF9: Device sector reassign successful"},
 258        {0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
 259        "FFF7: Media error recovered by device rewrite procedures"},
 260        {0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
 261        "7001: IOA sector reassignment successful"},
 262        {0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
 263        "FFF9: Soft media error. Sector reassignment recommended"},
 264        {0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
 265        "FFF7: Media error recovered by IOA rewrite procedures"},
 266        {0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
 267        "FF3D: Soft PCI bus error recovered by the IOA"},
 268        {0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
 269        "FFF6: Device hardware error recovered by the IOA"},
 270        {0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
 271        "FFF6: Device hardware error recovered by the device"},
 272        {0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
 273        "FF3D: Soft IOA error recovered by the IOA"},
 274        {0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
 275        "FFFA: Undefined device response recovered by the IOA"},
 276        {0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
 277        "FFF6: Device bus error, message or command phase"},
 278        {0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
 279        "FFFE: Task Management Function failed"},
 280        {0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
 281        "FFF6: Failure prediction threshold exceeded"},
 282        {0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
 283        "8009: Impending cache battery pack failure"},
 284        {0x02040400, 0, 0,
 285        "34FF: Disk device format in progress"},
 286        {0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
 287        "9070: IOA requested reset"},
 288        {0x023F0000, 0, 0,
 289        "Synchronization required"},
 290        {0x024E0000, 0, 0,
 291        "No ready, IOA shutdown"},
 292        {0x025A0000, 0, 0,
 293        "Not ready, IOA has been shutdown"},
 294        {0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
 295        "3020: Storage subsystem configuration error"},
 296        {0x03110B00, 0, 0,
 297        "FFF5: Medium error, data unreadable, recommend reassign"},
 298        {0x03110C00, 0, 0,
 299        "7000: Medium error, data unreadable, do not reassign"},
 300        {0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
 301        "FFF3: Disk media format bad"},
 302        {0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
 303        "3002: Addressed device failed to respond to selection"},
 304        {0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
 305        "3100: Device bus error"},
 306        {0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
 307        "3109: IOA timed out a device command"},
 308        {0x04088000, 0, 0,
 309        "3120: SCSI bus is not operational"},
 310        {0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
 311        "4100: Hard device bus fabric error"},
 312        {0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
 313        "310C: Logical block guard error detected by the device"},
 314        {0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
 315        "310C: Logical block reference tag error detected by the device"},
 316        {0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
 317        "4170: Scatter list tag / sequence number error"},
 318        {0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
 319        "8150: Logical block CRC error on IOA to Host transfer"},
 320        {0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
 321        "4170: Logical block sequence number error on IOA to Host transfer"},
 322        {0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
 323        "310D: Logical block reference tag error detected by the IOA"},
 324        {0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
 325        "310D: Logical block guard error detected by the IOA"},
 326        {0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
 327        "9000: IOA reserved area data check"},
 328        {0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
 329        "9001: IOA reserved area invalid data pattern"},
 330        {0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
 331        "9002: IOA reserved area LRC error"},
 332        {0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
 333        "Hardware Error, IOA metadata access error"},
 334        {0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
 335        "102E: Out of alternate sectors for disk storage"},
 336        {0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
 337        "FFF4: Data transfer underlength error"},
 338        {0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
 339        "FFF4: Data transfer overlength error"},
 340        {0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
 341        "3400: Logical unit failure"},
 342        {0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
 343        "FFF4: Device microcode is corrupt"},
 344        {0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
 345        "8150: PCI bus error"},
 346        {0x04430000, 1, 0,
 347        "Unsupported device bus message received"},
 348        {0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
 349        "FFF4: Disk device problem"},
 350        {0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
 351        "8150: Permanent IOA failure"},
 352        {0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
 353        "3010: Disk device returned wrong response to IOA"},
 354        {0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
 355        "8151: IOA microcode error"},
 356        {0x04448500, 0, 0,
 357        "Device bus status error"},
 358        {0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
 359        "8157: IOA error requiring IOA reset to recover"},
 360        {0x04448700, 0, 0,
 361        "ATA device status error"},
 362        {0x04490000, 0, 0,
 363        "Message reject received from the device"},
 364        {0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
 365        "8008: A permanent cache battery pack failure occurred"},
 366        {0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
 367        "9090: Disk unit has been modified after the last known status"},
 368        {0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
 369        "9081: IOA detected device error"},
 370        {0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
 371        "9082: IOA detected device error"},
 372        {0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
 373        "3110: Device bus error, message or command phase"},
 374        {0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
 375        "3110: SAS Command / Task Management Function failed"},
 376        {0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
 377        "9091: Incorrect hardware configuration change has been detected"},
 378        {0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
 379        "9073: Invalid multi-adapter configuration"},
 380        {0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
 381        "4010: Incorrect connection between cascaded expanders"},
 382        {0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
 383        "4020: Connections exceed IOA design limits"},
 384        {0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
 385        "4030: Incorrect multipath connection"},
 386        {0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
 387        "4110: Unsupported enclosure function"},
 388        {0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
 389        "FFF4: Command to logical unit failed"},
 390        {0x05240000, 1, 0,
 391        "Illegal request, invalid request type or request packet"},
 392        {0x05250000, 0, 0,
 393        "Illegal request, invalid resource handle"},
 394        {0x05258000, 0, 0,
 395        "Illegal request, commands not allowed to this device"},
 396        {0x05258100, 0, 0,
 397        "Illegal request, command not allowed to a secondary adapter"},
 398        {0x05258200, 0, 0,
 399        "Illegal request, command not allowed to a non-optimized resource"},
 400        {0x05260000, 0, 0,
 401        "Illegal request, invalid field in parameter list"},
 402        {0x05260100, 0, 0,
 403        "Illegal request, parameter not supported"},
 404        {0x05260200, 0, 0,
 405        "Illegal request, parameter value invalid"},
 406        {0x052C0000, 0, 0,
 407        "Illegal request, command sequence error"},
 408        {0x052C8000, 1, 0,
 409        "Illegal request, dual adapter support not enabled"},
 410        {0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
 411        "9031: Array protection temporarily suspended, protection resuming"},
 412        {0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
 413        "9040: Array protection temporarily suspended, protection resuming"},
 414        {0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
 415        "3140: Device bus not ready to ready transition"},
 416        {0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
 417        "FFFB: SCSI bus was reset"},
 418        {0x06290500, 0, 0,
 419        "FFFE: SCSI bus transition to single ended"},
 420        {0x06290600, 0, 0,
 421        "FFFE: SCSI bus transition to LVD"},
 422        {0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
 423        "FFFB: SCSI bus was reset by another initiator"},
 424        {0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
 425        "3029: A device replacement has occurred"},
 426        {0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
 427        "9051: IOA cache data exists for a missing or failed device"},
 428        {0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
 429        "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
 430        {0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
 431        "9025: Disk unit is not supported at its physical location"},
 432        {0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
 433        "3020: IOA detected a SCSI bus configuration error"},
 434        {0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
 435        "3150: SCSI bus configuration error"},
 436        {0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
 437        "9074: Asymmetric advanced function disk configuration"},
 438        {0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
 439        "4040: Incomplete multipath connection between IOA and enclosure"},
 440        {0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
 441        "4041: Incomplete multipath connection between enclosure and device"},
 442        {0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
 443        "9075: Incomplete multipath connection between IOA and remote IOA"},
 444        {0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
 445        "9076: Configuration error, missing remote IOA"},
 446        {0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
 447        "4050: Enclosure does not support a required multipath function"},
 448        {0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
 449        "4070: Logically bad block written on device"},
 450        {0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
 451        "9041: Array protection temporarily suspended"},
 452        {0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
 453        "9042: Corrupt array parity detected on specified device"},
 454        {0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
 455        "9030: Array no longer protected due to missing or failed disk unit"},
 456        {0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
 457        "9071: Link operational transition"},
 458        {0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
 459        "9072: Link not operational transition"},
 460        {0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
 461        "9032: Array exposed but still protected"},
 462        {0x066B8300, 0, IPR_DEFAULT_LOG_LEVEL + 1,
 463        "70DD: Device forced failed by disrupt device command"},
 464        {0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
 465        "4061: Multipath redundancy level got better"},
 466        {0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
 467        "4060: Multipath redundancy level got worse"},
 468        {0x07270000, 0, 0,
 469        "Failure due to other device"},
 470        {0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
 471        "9008: IOA does not support functions expected by devices"},
 472        {0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
 473        "9010: Cache data associated with attached devices cannot be found"},
 474        {0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
 475        "9011: Cache data belongs to devices other than those attached"},
 476        {0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
 477        "9020: Array missing 2 or more devices with only 1 device present"},
 478        {0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
 479        "9021: Array missing 2 or more devices with 2 or more devices present"},
 480        {0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
 481        "9022: Exposed array is missing a required device"},
 482        {0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
 483        "9023: Array member(s) not at required physical locations"},
 484        {0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
 485        "9024: Array not functional due to present hardware configuration"},
 486        {0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
 487        "9026: Array not functional due to present hardware configuration"},
 488        {0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
 489        "9027: Array is missing a device and parity is out of sync"},
 490        {0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
 491        "9028: Maximum number of arrays already exist"},
 492        {0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
 493        "9050: Required cache data cannot be located for a disk unit"},
 494        {0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
 495        "9052: Cache data exists for a device that has been modified"},
 496        {0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
 497        "9054: IOA resources not available due to previous problems"},
 498        {0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
 499        "9092: Disk unit requires initialization before use"},
 500        {0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
 501        "9029: Incorrect hardware configuration change has been detected"},
 502        {0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
 503        "9060: One or more disk pairs are missing from an array"},
 504        {0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
 505        "9061: One or more disks are missing from an array"},
 506        {0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
 507        "9062: One or more disks are missing from an array"},
 508        {0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
 509        "9063: Maximum number of functional arrays has been exceeded"},
 510        {0x0B260000, 0, 0,
 511        "Aborted command, invalid descriptor"},
 512        {0x0B5A0000, 0, 0,
 513        "Command terminated by host"}
 514};
 515
 516static const struct ipr_ses_table_entry ipr_ses_table[] = {
 517        { "2104-DL1        ", "XXXXXXXXXXXXXXXX", 80 },
 518        { "2104-TL1        ", "XXXXXXXXXXXXXXXX", 80 },
 519        { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
 520        { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
 521        { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
 522        { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
 523        { "2104-DU3        ", "XXXXXXXXXXXXXXXX", 160 },
 524        { "2104-TU3        ", "XXXXXXXXXXXXXXXX", 160 },
 525        { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
 526        { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
 527        { "St  V1S2        ", "XXXXXXXXXXXXXXXX", 160 },
 528        { "HSBPD4M  PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
 529        { "VSBPD1H   U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
 530};
 531
 532/*
 533 *  Function Prototypes
 534 */
 535static int ipr_reset_alert(struct ipr_cmnd *);
 536static void ipr_process_ccn(struct ipr_cmnd *);
 537static void ipr_process_error(struct ipr_cmnd *);
 538static void ipr_reset_ioa_job(struct ipr_cmnd *);
 539static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
 540                                   enum ipr_shutdown_type);
 541
 542#ifdef CONFIG_SCSI_IPR_TRACE
 543/**
 544 * ipr_trc_hook - Add a trace entry to the driver trace
 545 * @ipr_cmd:    ipr command struct
 546 * @type:               trace type
 547 * @add_data:   additional data
 548 *
 549 * Return value:
 550 *      none
 551 **/
 552static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
 553                         u8 type, u32 add_data)
 554{
 555        struct ipr_trace_entry *trace_entry;
 556        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 557
 558        trace_entry = &ioa_cfg->trace[atomic_add_return
 559                        (1, &ioa_cfg->trace_index)%IPR_NUM_TRACE_ENTRIES];
 560        trace_entry->time = jiffies;
 561        trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
 562        trace_entry->type = type;
 563        if (ipr_cmd->ioa_cfg->sis64)
 564                trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
 565        else
 566                trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
 567        trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
 568        trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
 569        trace_entry->u.add_data = add_data;
 570        wmb();
 571}
 572#else
 573#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
 574#endif
 575
 576/**
 577 * ipr_lock_and_done - Acquire lock and complete command
 578 * @ipr_cmd:    ipr command struct
 579 *
 580 * Return value:
 581 *      none
 582 **/
 583static void ipr_lock_and_done(struct ipr_cmnd *ipr_cmd)
 584{
 585        unsigned long lock_flags;
 586        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 587
 588        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
 589        ipr_cmd->done(ipr_cmd);
 590        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
 591}
 592
 593/**
 594 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
 595 * @ipr_cmd:    ipr command struct
 596 *
 597 * Return value:
 598 *      none
 599 **/
 600static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
 601{
 602        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
 603        struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
 604        struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
 605        dma_addr_t dma_addr = ipr_cmd->dma_addr;
 606        int hrrq_id;
 607
 608        hrrq_id = ioarcb->cmd_pkt.hrrq_id;
 609        memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
 610        ioarcb->cmd_pkt.hrrq_id = hrrq_id;
 611        ioarcb->data_transfer_length = 0;
 612        ioarcb->read_data_transfer_length = 0;
 613        ioarcb->ioadl_len = 0;
 614        ioarcb->read_ioadl_len = 0;
 615
 616        if (ipr_cmd->ioa_cfg->sis64) {
 617                ioarcb->u.sis64_addr_data.data_ioadl_addr =
 618                        cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
 619                ioasa64->u.gata.status = 0;
 620        } else {
 621                ioarcb->write_ioadl_addr =
 622                        cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
 623                ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
 624                ioasa->u.gata.status = 0;
 625        }
 626
 627        ioasa->hdr.ioasc = 0;
 628        ioasa->hdr.residual_data_len = 0;
 629        ipr_cmd->scsi_cmd = NULL;
 630        ipr_cmd->qc = NULL;
 631        ipr_cmd->sense_buffer[0] = 0;
 632        ipr_cmd->dma_use_sg = 0;
 633}
 634
 635/**
 636 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
 637 * @ipr_cmd:    ipr command struct
 638 *
 639 * Return value:
 640 *      none
 641 **/
 642static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd,
 643                              void (*fast_done) (struct ipr_cmnd *))
 644{
 645        ipr_reinit_ipr_cmnd(ipr_cmd);
 646        ipr_cmd->u.scratch = 0;
 647        ipr_cmd->sibling = NULL;
 648        ipr_cmd->fast_done = fast_done;
 649        init_timer(&ipr_cmd->timer);
 650}
 651
 652/**
 653 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
 654 * @ioa_cfg:    ioa config struct
 655 *
 656 * Return value:
 657 *      pointer to ipr command struct
 658 **/
 659static
 660struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq)
 661{
 662        struct ipr_cmnd *ipr_cmd = NULL;
 663
 664        if (likely(!list_empty(&hrrq->hrrq_free_q))) {
 665                ipr_cmd = list_entry(hrrq->hrrq_free_q.next,
 666                        struct ipr_cmnd, queue);
 667                list_del(&ipr_cmd->queue);
 668        }
 669
 670
 671        return ipr_cmd;
 672}
 673
 674/**
 675 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
 676 * @ioa_cfg:    ioa config struct
 677 *
 678 * Return value:
 679 *      pointer to ipr command struct
 680 **/
 681static
 682struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
 683{
 684        struct ipr_cmnd *ipr_cmd =
 685                __ipr_get_free_ipr_cmnd(&ioa_cfg->hrrq[IPR_INIT_HRRQ]);
 686        ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
 687        return ipr_cmd;
 688}
 689
 690/**
 691 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
 692 * @ioa_cfg:    ioa config struct
 693 * @clr_ints:     interrupts to clear
 694 *
 695 * This function masks all interrupts on the adapter, then clears the
 696 * interrupts specified in the mask
 697 *
 698 * Return value:
 699 *      none
 700 **/
 701static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
 702                                          u32 clr_ints)
 703{
 704        volatile u32 int_reg;
 705        int i;
 706
 707        /* Stop new interrupts */
 708        for (i = 0; i < ioa_cfg->hrrq_num; i++) {
 709                spin_lock(&ioa_cfg->hrrq[i]._lock);
 710                ioa_cfg->hrrq[i].allow_interrupts = 0;
 711                spin_unlock(&ioa_cfg->hrrq[i]._lock);
 712        }
 713        wmb();
 714
 715        /* Set interrupt mask to stop all new interrupts */
 716        if (ioa_cfg->sis64)
 717                writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
 718        else
 719                writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
 720
 721        /* Clear any pending interrupts */
 722        if (ioa_cfg->sis64)
 723                writel(~0, ioa_cfg->regs.clr_interrupt_reg);
 724        writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
 725        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
 726}
 727
 728/**
 729 * ipr_save_pcix_cmd_reg - Save PCI-X command register
 730 * @ioa_cfg:    ioa config struct
 731 *
 732 * Return value:
 733 *      0 on success / -EIO on failure
 734 **/
 735static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
 736{
 737        int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
 738
 739        if (pcix_cmd_reg == 0)
 740                return 0;
 741
 742        if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
 743                                 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
 744                dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
 745                return -EIO;
 746        }
 747
 748        ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
 749        return 0;
 750}
 751
 752/**
 753 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
 754 * @ioa_cfg:    ioa config struct
 755 *
 756 * Return value:
 757 *      0 on success / -EIO on failure
 758 **/
 759static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
 760{
 761        int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
 762
 763        if (pcix_cmd_reg) {
 764                if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
 765                                          ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
 766                        dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
 767                        return -EIO;
 768                }
 769        }
 770
 771        return 0;
 772}
 773
 774/**
 775 * ipr_sata_eh_done - done function for aborted SATA commands
 776 * @ipr_cmd:    ipr command struct
 777 *
 778 * This function is invoked for ops generated to SATA
 779 * devices which are being aborted.
 780 *
 781 * Return value:
 782 *      none
 783 **/
 784static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
 785{
 786        struct ata_queued_cmd *qc = ipr_cmd->qc;
 787        struct ipr_sata_port *sata_port = qc->ap->private_data;
 788
 789        qc->err_mask |= AC_ERR_OTHER;
 790        sata_port->ioasa.status |= ATA_BUSY;
 791        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
 792        ata_qc_complete(qc);
 793}
 794
 795/**
 796 * ipr_scsi_eh_done - mid-layer done function for aborted ops
 797 * @ipr_cmd:    ipr command struct
 798 *
 799 * This function is invoked by the interrupt handler for
 800 * ops generated by the SCSI mid-layer which are being aborted.
 801 *
 802 * Return value:
 803 *      none
 804 **/
 805static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
 806{
 807        struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
 808
 809        scsi_cmd->result |= (DID_ERROR << 16);
 810
 811        scsi_dma_unmap(ipr_cmd->scsi_cmd);
 812        scsi_cmd->scsi_done(scsi_cmd);
 813        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
 814}
 815
 816/**
 817 * ipr_fail_all_ops - Fails all outstanding ops.
 818 * @ioa_cfg:    ioa config struct
 819 *
 820 * This function fails all outstanding ops.
 821 *
 822 * Return value:
 823 *      none
 824 **/
 825static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
 826{
 827        struct ipr_cmnd *ipr_cmd, *temp;
 828        struct ipr_hrr_queue *hrrq;
 829
 830        ENTER;
 831        for_each_hrrq(hrrq, ioa_cfg) {
 832                spin_lock(&hrrq->_lock);
 833                list_for_each_entry_safe(ipr_cmd,
 834                                        temp, &hrrq->hrrq_pending_q, queue) {
 835                        list_del(&ipr_cmd->queue);
 836
 837                        ipr_cmd->s.ioasa.hdr.ioasc =
 838                                cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
 839                        ipr_cmd->s.ioasa.hdr.ilid =
 840                                cpu_to_be32(IPR_DRIVER_ILID);
 841
 842                        if (ipr_cmd->scsi_cmd)
 843                                ipr_cmd->done = ipr_scsi_eh_done;
 844                        else if (ipr_cmd->qc)
 845                                ipr_cmd->done = ipr_sata_eh_done;
 846
 847                        ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH,
 848                                     IPR_IOASC_IOA_WAS_RESET);
 849                        del_timer(&ipr_cmd->timer);
 850                        ipr_cmd->done(ipr_cmd);
 851                }
 852                spin_unlock(&hrrq->_lock);
 853        }
 854        LEAVE;
 855}
 856
 857/**
 858 * ipr_send_command -  Send driver initiated requests.
 859 * @ipr_cmd:            ipr command struct
 860 *
 861 * This function sends a command to the adapter using the correct write call.
 862 * In the case of sis64, calculate the ioarcb size required. Then or in the
 863 * appropriate bits.
 864 *
 865 * Return value:
 866 *      none
 867 **/
 868static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
 869{
 870        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 871        dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
 872
 873        if (ioa_cfg->sis64) {
 874                /* The default size is 256 bytes */
 875                send_dma_addr |= 0x1;
 876
 877                /* If the number of ioadls * size of ioadl > 128 bytes,
 878                   then use a 512 byte ioarcb */
 879                if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
 880                        send_dma_addr |= 0x4;
 881                writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
 882        } else
 883                writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
 884}
 885
 886/**
 887 * ipr_do_req -  Send driver initiated requests.
 888 * @ipr_cmd:            ipr command struct
 889 * @done:                       done function
 890 * @timeout_func:       timeout function
 891 * @timeout:            timeout value
 892 *
 893 * This function sends the specified command to the adapter with the
 894 * timeout given. The done function is invoked on command completion.
 895 *
 896 * Return value:
 897 *      none
 898 **/
 899static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
 900                       void (*done) (struct ipr_cmnd *),
 901                       void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
 902{
 903        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
 904
 905        ipr_cmd->done = done;
 906
 907        ipr_cmd->timer.data = (unsigned long) ipr_cmd;
 908        ipr_cmd->timer.expires = jiffies + timeout;
 909        ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
 910
 911        add_timer(&ipr_cmd->timer);
 912
 913        ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
 914
 915        ipr_send_command(ipr_cmd);
 916}
 917
 918/**
 919 * ipr_internal_cmd_done - Op done function for an internally generated op.
 920 * @ipr_cmd:    ipr command struct
 921 *
 922 * This function is the op done function for an internally generated,
 923 * blocking op. It simply wakes the sleeping thread.
 924 *
 925 * Return value:
 926 *      none
 927 **/
 928static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
 929{
 930        if (ipr_cmd->sibling)
 931                ipr_cmd->sibling = NULL;
 932        else
 933                complete(&ipr_cmd->completion);
 934}
 935
 936/**
 937 * ipr_init_ioadl - initialize the ioadl for the correct SIS type
 938 * @ipr_cmd:    ipr command struct
 939 * @dma_addr:   dma address
 940 * @len:        transfer length
 941 * @flags:      ioadl flag value
 942 *
 943 * This function initializes an ioadl in the case where there is only a single
 944 * descriptor.
 945 *
 946 * Return value:
 947 *      nothing
 948 **/
 949static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
 950                           u32 len, int flags)
 951{
 952        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
 953        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
 954
 955        ipr_cmd->dma_use_sg = 1;
 956
 957        if (ipr_cmd->ioa_cfg->sis64) {
 958                ioadl64->flags = cpu_to_be32(flags);
 959                ioadl64->data_len = cpu_to_be32(len);
 960                ioadl64->address = cpu_to_be64(dma_addr);
 961
 962                ipr_cmd->ioarcb.ioadl_len =
 963                        cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
 964                ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
 965        } else {
 966                ioadl->flags_and_data_len = cpu_to_be32(flags | len);
 967                ioadl->address = cpu_to_be32(dma_addr);
 968
 969                if (flags == IPR_IOADL_FLAGS_READ_LAST) {
 970                        ipr_cmd->ioarcb.read_ioadl_len =
 971                                cpu_to_be32(sizeof(struct ipr_ioadl_desc));
 972                        ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
 973                } else {
 974                        ipr_cmd->ioarcb.ioadl_len =
 975                                cpu_to_be32(sizeof(struct ipr_ioadl_desc));
 976                        ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
 977                }
 978        }
 979}
 980
 981/**
 982 * ipr_send_blocking_cmd - Send command and sleep on its completion.
 983 * @ipr_cmd:    ipr command struct
 984 * @timeout_func:       function to invoke if command times out
 985 * @timeout:    timeout
 986 *
 987 * Return value:
 988 *      none
 989 **/
 990static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
 991                                  void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
 992                                  u32 timeout)
 993{
 994        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 995
 996        init_completion(&ipr_cmd->completion);
 997        ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
 998
 999        spin_unlock_irq(ioa_cfg->host->host_lock);
1000        wait_for_completion(&ipr_cmd->completion);
1001        spin_lock_irq(ioa_cfg->host->host_lock);
1002}
1003
1004static int ipr_get_hrrq_index(struct ipr_ioa_cfg *ioa_cfg)
1005{
1006        if (ioa_cfg->hrrq_num == 1)
1007                return 0;
1008        else
1009                return (atomic_add_return(1, &ioa_cfg->hrrq_index) % (ioa_cfg->hrrq_num - 1)) + 1;
1010}
1011
1012/**
1013 * ipr_send_hcam - Send an HCAM to the adapter.
1014 * @ioa_cfg:    ioa config struct
1015 * @type:               HCAM type
1016 * @hostrcb:    hostrcb struct
1017 *
1018 * This function will send a Host Controlled Async command to the adapter.
1019 * If HCAMs are currently not allowed to be issued to the adapter, it will
1020 * place the hostrcb on the free queue.
1021 *
1022 * Return value:
1023 *      none
1024 **/
1025static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
1026                          struct ipr_hostrcb *hostrcb)
1027{
1028        struct ipr_cmnd *ipr_cmd;
1029        struct ipr_ioarcb *ioarcb;
1030
1031        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
1032                ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
1033                list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
1034                list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
1035
1036                ipr_cmd->u.hostrcb = hostrcb;
1037                ioarcb = &ipr_cmd->ioarcb;
1038
1039                ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
1040                ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
1041                ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
1042                ioarcb->cmd_pkt.cdb[1] = type;
1043                ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
1044                ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
1045
1046                ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
1047                               sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
1048
1049                if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
1050                        ipr_cmd->done = ipr_process_ccn;
1051                else
1052                        ipr_cmd->done = ipr_process_error;
1053
1054                ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
1055
1056                ipr_send_command(ipr_cmd);
1057        } else {
1058                list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
1059        }
1060}
1061
1062/**
1063 * ipr_update_ata_class - Update the ata class in the resource entry
1064 * @res:        resource entry struct
1065 * @proto:      cfgte device bus protocol value
1066 *
1067 * Return value:
1068 *      none
1069 **/
1070static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1071{
1072        switch (proto) {
1073        case IPR_PROTO_SATA:
1074        case IPR_PROTO_SAS_STP:
1075                res->ata_class = ATA_DEV_ATA;
1076                break;
1077        case IPR_PROTO_SATA_ATAPI:
1078        case IPR_PROTO_SAS_STP_ATAPI:
1079                res->ata_class = ATA_DEV_ATAPI;
1080                break;
1081        default:
1082                res->ata_class = ATA_DEV_UNKNOWN;
1083                break;
1084        };
1085}
1086
1087/**
1088 * ipr_init_res_entry - Initialize a resource entry struct.
1089 * @res:        resource entry struct
1090 * @cfgtew:     config table entry wrapper struct
1091 *
1092 * Return value:
1093 *      none
1094 **/
1095static void ipr_init_res_entry(struct ipr_resource_entry *res,
1096                               struct ipr_config_table_entry_wrapper *cfgtew)
1097{
1098        int found = 0;
1099        unsigned int proto;
1100        struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1101        struct ipr_resource_entry *gscsi_res = NULL;
1102
1103        res->needs_sync_complete = 0;
1104        res->in_erp = 0;
1105        res->add_to_ml = 0;
1106        res->del_from_ml = 0;
1107        res->resetting_device = 0;
1108        res->sdev = NULL;
1109        res->sata_port = NULL;
1110
1111        if (ioa_cfg->sis64) {
1112                proto = cfgtew->u.cfgte64->proto;
1113                res->res_flags = cfgtew->u.cfgte64->res_flags;
1114                res->qmodel = IPR_QUEUEING_MODEL64(res);
1115                res->type = cfgtew->u.cfgte64->res_type;
1116
1117                memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1118                        sizeof(res->res_path));
1119
1120                res->bus = 0;
1121                memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1122                        sizeof(res->dev_lun.scsi_lun));
1123                res->lun = scsilun_to_int(&res->dev_lun);
1124
1125                if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1126                        list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
1127                                if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
1128                                        found = 1;
1129                                        res->target = gscsi_res->target;
1130                                        break;
1131                                }
1132                        }
1133                        if (!found) {
1134                                res->target = find_first_zero_bit(ioa_cfg->target_ids,
1135                                                                  ioa_cfg->max_devs_supported);
1136                                set_bit(res->target, ioa_cfg->target_ids);
1137                        }
1138                } else if (res->type == IPR_RES_TYPE_IOAFP) {
1139                        res->bus = IPR_IOAFP_VIRTUAL_BUS;
1140                        res->target = 0;
1141                } else if (res->type == IPR_RES_TYPE_ARRAY) {
1142                        res->bus = IPR_ARRAY_VIRTUAL_BUS;
1143                        res->target = find_first_zero_bit(ioa_cfg->array_ids,
1144                                                          ioa_cfg->max_devs_supported);
1145                        set_bit(res->target, ioa_cfg->array_ids);
1146                } else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
1147                        res->bus = IPR_VSET_VIRTUAL_BUS;
1148                        res->target = find_first_zero_bit(ioa_cfg->vset_ids,
1149                                                          ioa_cfg->max_devs_supported);
1150                        set_bit(res->target, ioa_cfg->vset_ids);
1151                } else {
1152                        res->target = find_first_zero_bit(ioa_cfg->target_ids,
1153                                                          ioa_cfg->max_devs_supported);
1154                        set_bit(res->target, ioa_cfg->target_ids);
1155                }
1156        } else {
1157                proto = cfgtew->u.cfgte->proto;
1158                res->qmodel = IPR_QUEUEING_MODEL(res);
1159                res->flags = cfgtew->u.cfgte->flags;
1160                if (res->flags & IPR_IS_IOA_RESOURCE)
1161                        res->type = IPR_RES_TYPE_IOAFP;
1162                else
1163                        res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1164
1165                res->bus = cfgtew->u.cfgte->res_addr.bus;
1166                res->target = cfgtew->u.cfgte->res_addr.target;
1167                res->lun = cfgtew->u.cfgte->res_addr.lun;
1168                res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
1169        }
1170
1171        ipr_update_ata_class(res, proto);
1172}
1173
1174/**
1175 * ipr_is_same_device - Determine if two devices are the same.
1176 * @res:        resource entry struct
1177 * @cfgtew:     config table entry wrapper struct
1178 *
1179 * Return value:
1180 *      1 if the devices are the same / 0 otherwise
1181 **/
1182static int ipr_is_same_device(struct ipr_resource_entry *res,
1183                              struct ipr_config_table_entry_wrapper *cfgtew)
1184{
1185        if (res->ioa_cfg->sis64) {
1186                if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
1187                                        sizeof(cfgtew->u.cfgte64->dev_id)) &&
1188                        !memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1189                                        sizeof(cfgtew->u.cfgte64->lun))) {
1190                        return 1;
1191                }
1192        } else {
1193                if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
1194                    res->target == cfgtew->u.cfgte->res_addr.target &&
1195                    res->lun == cfgtew->u.cfgte->res_addr.lun)
1196                        return 1;
1197        }
1198
1199        return 0;
1200}
1201
1202/**
1203 * __ipr_format_res_path - Format the resource path for printing.
1204 * @res_path:   resource path
1205 * @buf:        buffer
1206 * @len:        length of buffer provided
1207 *
1208 * Return value:
1209 *      pointer to buffer
1210 **/
1211static char *__ipr_format_res_path(u8 *res_path, char *buffer, int len)
1212{
1213        int i;
1214        char *p = buffer;
1215
1216        *p = '\0';
1217        p += snprintf(p, buffer + len - p, "%02X", res_path[0]);
1218        for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++)
1219                p += snprintf(p, buffer + len - p, "-%02X", res_path[i]);
1220
1221        return buffer;
1222}
1223
1224/**
1225 * ipr_format_res_path - Format the resource path for printing.
1226 * @ioa_cfg:    ioa config struct
1227 * @res_path:   resource path
1228 * @buf:        buffer
1229 * @len:        length of buffer provided
1230 *
1231 * Return value:
1232 *      pointer to buffer
1233 **/
1234static char *ipr_format_res_path(struct ipr_ioa_cfg *ioa_cfg,
1235                                 u8 *res_path, char *buffer, int len)
1236{
1237        char *p = buffer;
1238
1239        *p = '\0';
1240        p += snprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no);
1241        __ipr_format_res_path(res_path, p, len - (buffer - p));
1242        return buffer;
1243}
1244
1245/**
1246 * ipr_update_res_entry - Update the resource entry.
1247 * @res:        resource entry struct
1248 * @cfgtew:     config table entry wrapper struct
1249 *
1250 * Return value:
1251 *      none
1252 **/
1253static void ipr_update_res_entry(struct ipr_resource_entry *res,
1254                                 struct ipr_config_table_entry_wrapper *cfgtew)
1255{
1256        char buffer[IPR_MAX_RES_PATH_LENGTH];
1257        unsigned int proto;
1258        int new_path = 0;
1259
1260        if (res->ioa_cfg->sis64) {
1261                res->flags = cfgtew->u.cfgte64->flags;
1262                res->res_flags = cfgtew->u.cfgte64->res_flags;
1263                res->type = cfgtew->u.cfgte64->res_type;
1264
1265                memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1266                        sizeof(struct ipr_std_inq_data));
1267
1268                res->qmodel = IPR_QUEUEING_MODEL64(res);
1269                proto = cfgtew->u.cfgte64->proto;
1270                res->res_handle = cfgtew->u.cfgte64->res_handle;
1271                res->dev_id = cfgtew->u.cfgte64->dev_id;
1272
1273                memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1274                        sizeof(res->dev_lun.scsi_lun));
1275
1276                if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
1277                                        sizeof(res->res_path))) {
1278                        memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1279                                sizeof(res->res_path));
1280                        new_path = 1;
1281                }
1282
1283                if (res->sdev && new_path)
1284                        sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
1285                                    ipr_format_res_path(res->ioa_cfg,
1286                                        res->res_path, buffer, sizeof(buffer)));
1287        } else {
1288                res->flags = cfgtew->u.cfgte->flags;
1289                if (res->flags & IPR_IS_IOA_RESOURCE)
1290                        res->type = IPR_RES_TYPE_IOAFP;
1291                else
1292                        res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1293
1294                memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1295                        sizeof(struct ipr_std_inq_data));
1296
1297                res->qmodel = IPR_QUEUEING_MODEL(res);
1298                proto = cfgtew->u.cfgte->proto;
1299                res->res_handle = cfgtew->u.cfgte->res_handle;
1300        }
1301
1302        ipr_update_ata_class(res, proto);
1303}
1304
1305/**
1306 * ipr_clear_res_target - Clear the bit in the bit map representing the target
1307 *                        for the resource.
1308 * @res:        resource entry struct
1309 * @cfgtew:     config table entry wrapper struct
1310 *
1311 * Return value:
1312 *      none
1313 **/
1314static void ipr_clear_res_target(struct ipr_resource_entry *res)
1315{
1316        struct ipr_resource_entry *gscsi_res = NULL;
1317        struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1318
1319        if (!ioa_cfg->sis64)
1320                return;
1321
1322        if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
1323                clear_bit(res->target, ioa_cfg->array_ids);
1324        else if (res->bus == IPR_VSET_VIRTUAL_BUS)
1325                clear_bit(res->target, ioa_cfg->vset_ids);
1326        else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1327                list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
1328                        if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
1329                                return;
1330                clear_bit(res->target, ioa_cfg->target_ids);
1331
1332        } else if (res->bus == 0)
1333                clear_bit(res->target, ioa_cfg->target_ids);
1334}
1335
1336/**
1337 * ipr_handle_config_change - Handle a config change from the adapter
1338 * @ioa_cfg:    ioa config struct
1339 * @hostrcb:    hostrcb
1340 *
1341 * Return value:
1342 *      none
1343 **/
1344static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1345                                     struct ipr_hostrcb *hostrcb)
1346{
1347        struct ipr_resource_entry *res = NULL;
1348        struct ipr_config_table_entry_wrapper cfgtew;
1349        __be32 cc_res_handle;
1350
1351        u32 is_ndn = 1;
1352
1353        if (ioa_cfg->sis64) {
1354                cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1355                cc_res_handle = cfgtew.u.cfgte64->res_handle;
1356        } else {
1357                cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1358                cc_res_handle = cfgtew.u.cfgte->res_handle;
1359        }
1360
1361        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1362                if (res->res_handle == cc_res_handle) {
1363                        is_ndn = 0;
1364                        break;
1365                }
1366        }
1367
1368        if (is_ndn) {
1369                if (list_empty(&ioa_cfg->free_res_q)) {
1370                        ipr_send_hcam(ioa_cfg,
1371                                      IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1372                                      hostrcb);
1373                        return;
1374                }
1375
1376                res = list_entry(ioa_cfg->free_res_q.next,
1377                                 struct ipr_resource_entry, queue);
1378
1379                list_del(&res->queue);
1380                ipr_init_res_entry(res, &cfgtew);
1381                list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1382        }
1383
1384        ipr_update_res_entry(res, &cfgtew);
1385
1386        if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1387                if (res->sdev) {
1388                        res->del_from_ml = 1;
1389                        res->res_handle = IPR_INVALID_RES_HANDLE;
1390                        if (ioa_cfg->allow_ml_add_del)
1391                                schedule_work(&ioa_cfg->work_q);
1392                } else {
1393                        ipr_clear_res_target(res);
1394                        list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1395                }
1396        } else if (!res->sdev || res->del_from_ml) {
1397                res->add_to_ml = 1;
1398                if (ioa_cfg->allow_ml_add_del)
1399                        schedule_work(&ioa_cfg->work_q);
1400        }
1401
1402        ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1403}
1404
1405/**
1406 * ipr_process_ccn - Op done function for a CCN.
1407 * @ipr_cmd:    ipr command struct
1408 *
1409 * This function is the op done function for a configuration
1410 * change notification host controlled async from the adapter.
1411 *
1412 * Return value:
1413 *      none
1414 **/
1415static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
1416{
1417        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1418        struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1419        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
1420
1421        list_del(&hostrcb->queue);
1422        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
1423
1424        if (ioasc) {
1425                if (ioasc != IPR_IOASC_IOA_WAS_RESET)
1426                        dev_err(&ioa_cfg->pdev->dev,
1427                                "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1428
1429                ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1430        } else {
1431                ipr_handle_config_change(ioa_cfg, hostrcb);
1432        }
1433}
1434
1435/**
1436 * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1437 * @i:          index into buffer
1438 * @buf:                string to modify
1439 *
1440 * This function will strip all trailing whitespace, pad the end
1441 * of the string with a single space, and NULL terminate the string.
1442 *
1443 * Return value:
1444 *      new length of string
1445 **/
1446static int strip_and_pad_whitespace(int i, char *buf)
1447{
1448        while (i && buf[i] == ' ')
1449                i--;
1450        buf[i+1] = ' ';
1451        buf[i+2] = '\0';
1452        return i + 2;
1453}
1454
1455/**
1456 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1457 * @prefix:             string to print at start of printk
1458 * @hostrcb:    hostrcb pointer
1459 * @vpd:                vendor/product id/sn struct
1460 *
1461 * Return value:
1462 *      none
1463 **/
1464static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1465                                struct ipr_vpd *vpd)
1466{
1467        char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
1468        int i = 0;
1469
1470        memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1471        i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
1472
1473        memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
1474        i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
1475
1476        memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
1477        buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
1478
1479        ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
1480}
1481
1482/**
1483 * ipr_log_vpd - Log the passed VPD to the error log.
1484 * @vpd:                vendor/product id/sn struct
1485 *
1486 * Return value:
1487 *      none
1488 **/
1489static void ipr_log_vpd(struct ipr_vpd *vpd)
1490{
1491        char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1492                    + IPR_SERIAL_NUM_LEN];
1493
1494        memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1495        memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1496               IPR_PROD_ID_LEN);
1497        buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1498        ipr_err("Vendor/Product ID: %s\n", buffer);
1499
1500        memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1501        buffer[IPR_SERIAL_NUM_LEN] = '\0';
1502        ipr_err("    Serial Number: %s\n", buffer);
1503}
1504
1505/**
1506 * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1507 * @prefix:             string to print at start of printk
1508 * @hostrcb:    hostrcb pointer
1509 * @vpd:                vendor/product id/sn/wwn struct
1510 *
1511 * Return value:
1512 *      none
1513 **/
1514static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1515                                    struct ipr_ext_vpd *vpd)
1516{
1517        ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1518        ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1519                     be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1520}
1521
1522/**
1523 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1524 * @vpd:                vendor/product id/sn/wwn struct
1525 *
1526 * Return value:
1527 *      none
1528 **/
1529static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1530{
1531        ipr_log_vpd(&vpd->vpd);
1532        ipr_err("    WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1533                be32_to_cpu(vpd->wwid[1]));
1534}
1535
1536/**
1537 * ipr_log_enhanced_cache_error - Log a cache error.
1538 * @ioa_cfg:    ioa config struct
1539 * @hostrcb:    hostrcb struct
1540 *
1541 * Return value:
1542 *      none
1543 **/
1544static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1545                                         struct ipr_hostrcb *hostrcb)
1546{
1547        struct ipr_hostrcb_type_12_error *error;
1548
1549        if (ioa_cfg->sis64)
1550                error = &hostrcb->hcam.u.error64.u.type_12_error;
1551        else
1552                error = &hostrcb->hcam.u.error.u.type_12_error;
1553
1554        ipr_err("-----Current Configuration-----\n");
1555        ipr_err("Cache Directory Card Information:\n");
1556        ipr_log_ext_vpd(&error->ioa_vpd);
1557        ipr_err("Adapter Card Information:\n");
1558        ipr_log_ext_vpd(&error->cfc_vpd);
1559
1560        ipr_err("-----Expected Configuration-----\n");
1561        ipr_err("Cache Directory Card Information:\n");
1562        ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1563        ipr_err("Adapter Card Information:\n");
1564        ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1565
1566        ipr_err("Additional IOA Data: %08X %08X %08X\n",
1567                     be32_to_cpu(error->ioa_data[0]),
1568                     be32_to_cpu(error->ioa_data[1]),
1569                     be32_to_cpu(error->ioa_data[2]));
1570}
1571
1572/**
1573 * ipr_log_cache_error - Log a cache error.
1574 * @ioa_cfg:    ioa config struct
1575 * @hostrcb:    hostrcb struct
1576 *
1577 * Return value:
1578 *      none
1579 **/
1580static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1581                                struct ipr_hostrcb *hostrcb)
1582{
1583        struct ipr_hostrcb_type_02_error *error =
1584                &hostrcb->hcam.u.error.u.type_02_error;
1585
1586        ipr_err("-----Current Configuration-----\n");
1587        ipr_err("Cache Directory Card Information:\n");
1588        ipr_log_vpd(&error->ioa_vpd);
1589        ipr_err("Adapter Card Information:\n");
1590        ipr_log_vpd(&error->cfc_vpd);
1591
1592        ipr_err("-----Expected Configuration-----\n");
1593        ipr_err("Cache Directory Card Information:\n");
1594        ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1595        ipr_err("Adapter Card Information:\n");
1596        ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1597
1598        ipr_err("Additional IOA Data: %08X %08X %08X\n",
1599                     be32_to_cpu(error->ioa_data[0]),
1600                     be32_to_cpu(error->ioa_data[1]),
1601                     be32_to_cpu(error->ioa_data[2]));
1602}
1603
1604/**
1605 * ipr_log_enhanced_config_error - Log a configuration error.
1606 * @ioa_cfg:    ioa config struct
1607 * @hostrcb:    hostrcb struct
1608 *
1609 * Return value:
1610 *      none
1611 **/
1612static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1613                                          struct ipr_hostrcb *hostrcb)
1614{
1615        int errors_logged, i;
1616        struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1617        struct ipr_hostrcb_type_13_error *error;
1618
1619        error = &hostrcb->hcam.u.error.u.type_13_error;
1620        errors_logged = be32_to_cpu(error->errors_logged);
1621
1622        ipr_err("Device Errors Detected/Logged: %d/%d\n",
1623                be32_to_cpu(error->errors_detected), errors_logged);
1624
1625        dev_entry = error->dev;
1626
1627        for (i = 0; i < errors_logged; i++, dev_entry++) {
1628                ipr_err_separator;
1629
1630                ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1631                ipr_log_ext_vpd(&dev_entry->vpd);
1632
1633                ipr_err("-----New Device Information-----\n");
1634                ipr_log_ext_vpd(&dev_entry->new_vpd);
1635
1636                ipr_err("Cache Directory Card Information:\n");
1637                ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1638
1639                ipr_err("Adapter Card Information:\n");
1640                ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1641        }
1642}
1643
1644/**
1645 * ipr_log_sis64_config_error - Log a device error.
1646 * @ioa_cfg:    ioa config struct
1647 * @hostrcb:    hostrcb struct
1648 *
1649 * Return value:
1650 *      none
1651 **/
1652static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1653                                       struct ipr_hostrcb *hostrcb)
1654{
1655        int errors_logged, i;
1656        struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1657        struct ipr_hostrcb_type_23_error *error;
1658        char buffer[IPR_MAX_RES_PATH_LENGTH];
1659
1660        error = &hostrcb->hcam.u.error64.u.type_23_error;
1661        errors_logged = be32_to_cpu(error->errors_logged);
1662
1663        ipr_err("Device Errors Detected/Logged: %d/%d\n",
1664                be32_to_cpu(error->errors_detected), errors_logged);
1665
1666        dev_entry = error->dev;
1667
1668        for (i = 0; i < errors_logged; i++, dev_entry++) {
1669                ipr_err_separator;
1670
1671                ipr_err("Device %d : %s", i + 1,
1672                        __ipr_format_res_path(dev_entry->res_path,
1673                                              buffer, sizeof(buffer)));
1674                ipr_log_ext_vpd(&dev_entry->vpd);
1675
1676                ipr_err("-----New Device Information-----\n");
1677                ipr_log_ext_vpd(&dev_entry->new_vpd);
1678
1679                ipr_err("Cache Directory Card Information:\n");
1680                ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1681
1682                ipr_err("Adapter Card Information:\n");
1683                ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1684        }
1685}
1686
1687/**
1688 * ipr_log_config_error - Log a configuration error.
1689 * @ioa_cfg:    ioa config struct
1690 * @hostrcb:    hostrcb struct
1691 *
1692 * Return value:
1693 *      none
1694 **/
1695static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1696                                 struct ipr_hostrcb *hostrcb)
1697{
1698        int errors_logged, i;
1699        struct ipr_hostrcb_device_data_entry *dev_entry;
1700        struct ipr_hostrcb_type_03_error *error;
1701
1702        error = &hostrcb->hcam.u.error.u.type_03_error;
1703        errors_logged = be32_to_cpu(error->errors_logged);
1704
1705        ipr_err("Device Errors Detected/Logged: %d/%d\n",
1706                be32_to_cpu(error->errors_detected), errors_logged);
1707
1708        dev_entry = error->dev;
1709
1710        for (i = 0; i < errors_logged; i++, dev_entry++) {
1711                ipr_err_separator;
1712
1713                ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1714                ipr_log_vpd(&dev_entry->vpd);
1715
1716                ipr_err("-----New Device Information-----\n");
1717                ipr_log_vpd(&dev_entry->new_vpd);
1718
1719                ipr_err("Cache Directory Card Information:\n");
1720                ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1721
1722                ipr_err("Adapter Card Information:\n");
1723                ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1724
1725                ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1726                        be32_to_cpu(dev_entry->ioa_data[0]),
1727                        be32_to_cpu(dev_entry->ioa_data[1]),
1728                        be32_to_cpu(dev_entry->ioa_data[2]),
1729                        be32_to_cpu(dev_entry->ioa_data[3]),
1730                        be32_to_cpu(dev_entry->ioa_data[4]));
1731        }
1732}
1733
1734/**
1735 * ipr_log_enhanced_array_error - Log an array configuration error.
1736 * @ioa_cfg:    ioa config struct
1737 * @hostrcb:    hostrcb struct
1738 *
1739 * Return value:
1740 *      none
1741 **/
1742static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1743                                         struct ipr_hostrcb *hostrcb)
1744{
1745        int i, num_entries;
1746        struct ipr_hostrcb_type_14_error *error;
1747        struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1748        const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1749
1750        error = &hostrcb->hcam.u.error.u.type_14_error;
1751
1752        ipr_err_separator;
1753
1754        ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1755                error->protection_level,
1756                ioa_cfg->host->host_no,
1757                error->last_func_vset_res_addr.bus,
1758                error->last_func_vset_res_addr.target,
1759                error->last_func_vset_res_addr.lun);
1760
1761        ipr_err_separator;
1762
1763        array_entry = error->array_member;
1764        num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1765                            ARRAY_SIZE(error->array_member));
1766
1767        for (i = 0; i < num_entries; i++, array_entry++) {
1768                if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1769                        continue;
1770
1771                if (be32_to_cpu(error->exposed_mode_adn) == i)
1772                        ipr_err("Exposed Array Member %d:\n", i);
1773                else
1774                        ipr_err("Array Member %d:\n", i);
1775
1776                ipr_log_ext_vpd(&array_entry->vpd);
1777                ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1778                ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1779                                 "Expected Location");
1780
1781                ipr_err_separator;
1782        }
1783}
1784
1785/**
1786 * ipr_log_array_error - Log an array configuration error.
1787 * @ioa_cfg:    ioa config struct
1788 * @hostrcb:    hostrcb struct
1789 *
1790 * Return value:
1791 *      none
1792 **/
1793static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1794                                struct ipr_hostrcb *hostrcb)
1795{
1796        int i;
1797        struct ipr_hostrcb_type_04_error *error;
1798        struct ipr_hostrcb_array_data_entry *array_entry;
1799        const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1800
1801        error = &hostrcb->hcam.u.error.u.type_04_error;
1802
1803        ipr_err_separator;
1804
1805        ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1806                error->protection_level,
1807                ioa_cfg->host->host_no,
1808                error->last_func_vset_res_addr.bus,
1809                error->last_func_vset_res_addr.target,
1810                error->last_func_vset_res_addr.lun);
1811
1812        ipr_err_separator;
1813
1814        array_entry = error->array_member;
1815
1816        for (i = 0; i < 18; i++) {
1817                if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1818                        continue;
1819
1820                if (be32_to_cpu(error->exposed_mode_adn) == i)
1821                        ipr_err("Exposed Array Member %d:\n", i);
1822                else
1823                        ipr_err("Array Member %d:\n", i);
1824
1825                ipr_log_vpd(&array_entry->vpd);
1826
1827                ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1828                ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1829                                 "Expected Location");
1830
1831                ipr_err_separator;
1832
1833                if (i == 9)
1834                        array_entry = error->array_member2;
1835                else
1836                        array_entry++;
1837        }
1838}
1839
1840/**
1841 * ipr_log_hex_data - Log additional hex IOA error data.
1842 * @ioa_cfg:    ioa config struct
1843 * @data:               IOA error data
1844 * @len:                data length
1845 *
1846 * Return value:
1847 *      none
1848 **/
1849static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, u32 *data, int len)
1850{
1851        int i;
1852
1853        if (len == 0)
1854                return;
1855
1856        if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1857                len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1858
1859        for (i = 0; i < len / 4; i += 4) {
1860                ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1861                        be32_to_cpu(data[i]),
1862                        be32_to_cpu(data[i+1]),
1863                        be32_to_cpu(data[i+2]),
1864                        be32_to_cpu(data[i+3]));
1865        }
1866}
1867
1868/**
1869 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1870 * @ioa_cfg:    ioa config struct
1871 * @hostrcb:    hostrcb struct
1872 *
1873 * Return value:
1874 *      none
1875 **/
1876static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1877                                            struct ipr_hostrcb *hostrcb)
1878{
1879        struct ipr_hostrcb_type_17_error *error;
1880
1881        if (ioa_cfg->sis64)
1882                error = &hostrcb->hcam.u.error64.u.type_17_error;
1883        else
1884                error = &hostrcb->hcam.u.error.u.type_17_error;
1885
1886        error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1887        strim(error->failure_reason);
1888
1889        ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1890                     be32_to_cpu(hostrcb->hcam.u.error.prc));
1891        ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1892        ipr_log_hex_data(ioa_cfg, error->data,
1893                         be32_to_cpu(hostrcb->hcam.length) -
1894                         (offsetof(struct ipr_hostrcb_error, u) +
1895                          offsetof(struct ipr_hostrcb_type_17_error, data)));
1896}
1897
1898/**
1899 * ipr_log_dual_ioa_error - Log a dual adapter error.
1900 * @ioa_cfg:    ioa config struct
1901 * @hostrcb:    hostrcb struct
1902 *
1903 * Return value:
1904 *      none
1905 **/
1906static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1907                                   struct ipr_hostrcb *hostrcb)
1908{
1909        struct ipr_hostrcb_type_07_error *error;
1910
1911        error = &hostrcb->hcam.u.error.u.type_07_error;
1912        error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1913        strim(error->failure_reason);
1914
1915        ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1916                     be32_to_cpu(hostrcb->hcam.u.error.prc));
1917        ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1918        ipr_log_hex_data(ioa_cfg, error->data,
1919                         be32_to_cpu(hostrcb->hcam.length) -
1920                         (offsetof(struct ipr_hostrcb_error, u) +
1921                          offsetof(struct ipr_hostrcb_type_07_error, data)));
1922}
1923
1924static const struct {
1925        u8 active;
1926        char *desc;
1927} path_active_desc[] = {
1928        { IPR_PATH_NO_INFO, "Path" },
1929        { IPR_PATH_ACTIVE, "Active path" },
1930        { IPR_PATH_NOT_ACTIVE, "Inactive path" }
1931};
1932
1933static const struct {
1934        u8 state;
1935        char *desc;
1936} path_state_desc[] = {
1937        { IPR_PATH_STATE_NO_INFO, "has no path state information available" },
1938        { IPR_PATH_HEALTHY, "is healthy" },
1939        { IPR_PATH_DEGRADED, "is degraded" },
1940        { IPR_PATH_FAILED, "is failed" }
1941};
1942
1943/**
1944 * ipr_log_fabric_path - Log a fabric path error
1945 * @hostrcb:    hostrcb struct
1946 * @fabric:             fabric descriptor
1947 *
1948 * Return value:
1949 *      none
1950 **/
1951static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
1952                                struct ipr_hostrcb_fabric_desc *fabric)
1953{
1954        int i, j;
1955        u8 path_state = fabric->path_state;
1956        u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1957        u8 state = path_state & IPR_PATH_STATE_MASK;
1958
1959        for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1960                if (path_active_desc[i].active != active)
1961                        continue;
1962
1963                for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1964                        if (path_state_desc[j].state != state)
1965                                continue;
1966
1967                        if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
1968                                ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
1969                                             path_active_desc[i].desc, path_state_desc[j].desc,
1970                                             fabric->ioa_port);
1971                        } else if (fabric->cascaded_expander == 0xff) {
1972                                ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
1973                                             path_active_desc[i].desc, path_state_desc[j].desc,
1974                                             fabric->ioa_port, fabric->phy);
1975                        } else if (fabric->phy == 0xff) {
1976                                ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
1977                                             path_active_desc[i].desc, path_state_desc[j].desc,
1978                                             fabric->ioa_port, fabric->cascaded_expander);
1979                        } else {
1980                                ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
1981                                             path_active_desc[i].desc, path_state_desc[j].desc,
1982                                             fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1983                        }
1984                        return;
1985                }
1986        }
1987
1988        ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
1989                fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1990}
1991
1992/**
1993 * ipr_log64_fabric_path - Log a fabric path error
1994 * @hostrcb:    hostrcb struct
1995 * @fabric:             fabric descriptor
1996 *
1997 * Return value:
1998 *      none
1999 **/
2000static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
2001                                  struct ipr_hostrcb64_fabric_desc *fabric)
2002{
2003        int i, j;
2004        u8 path_state = fabric->path_state;
2005        u8 active = path_state & IPR_PATH_ACTIVE_MASK;
2006        u8 state = path_state & IPR_PATH_STATE_MASK;
2007        char buffer[IPR_MAX_RES_PATH_LENGTH];
2008
2009        for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
2010                if (path_active_desc[i].active != active)
2011                        continue;
2012
2013                for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
2014                        if (path_state_desc[j].state != state)
2015                                continue;
2016
2017                        ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
2018                                     path_active_desc[i].desc, path_state_desc[j].desc,
2019                                     ipr_format_res_path(hostrcb->ioa_cfg,
2020                                                fabric->res_path,
2021                                                buffer, sizeof(buffer)));
2022                        return;
2023                }
2024        }
2025
2026        ipr_err("Path state=%02X Resource Path=%s\n", path_state,
2027                ipr_format_res_path(hostrcb->ioa_cfg, fabric->res_path,
2028                                    buffer, sizeof(buffer)));
2029}
2030
2031static const struct {
2032        u8 type;
2033        char *desc;
2034} path_type_desc[] = {
2035        { IPR_PATH_CFG_IOA_PORT, "IOA port" },
2036        { IPR_PATH_CFG_EXP_PORT, "Expander port" },
2037        { IPR_PATH_CFG_DEVICE_PORT, "Device port" },
2038        { IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
2039};
2040
2041static const struct {
2042        u8 status;
2043        char *desc;
2044} path_status_desc[] = {
2045        { IPR_PATH_CFG_NO_PROB, "Functional" },
2046        { IPR_PATH_CFG_DEGRADED, "Degraded" },
2047        { IPR_PATH_CFG_FAILED, "Failed" },
2048        { IPR_PATH_CFG_SUSPECT, "Suspect" },
2049        { IPR_PATH_NOT_DETECTED, "Missing" },
2050        { IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
2051};
2052
2053static const char *link_rate[] = {
2054        "unknown",
2055        "disabled",
2056        "phy reset problem",
2057        "spinup hold",
2058        "port selector",
2059        "unknown",
2060        "unknown",
2061        "unknown",
2062        "1.5Gbps",
2063        "3.0Gbps",
2064        "unknown",
2065        "unknown",
2066        "unknown",
2067        "unknown",
2068        "unknown",
2069        "unknown"
2070};
2071
2072/**
2073 * ipr_log_path_elem - Log a fabric path element.
2074 * @hostrcb:    hostrcb struct
2075 * @cfg:                fabric path element struct
2076 *
2077 * Return value:
2078 *      none
2079 **/
2080static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
2081                              struct ipr_hostrcb_config_element *cfg)
2082{
2083        int i, j;
2084        u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2085        u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2086
2087        if (type == IPR_PATH_CFG_NOT_EXIST)
2088                return;
2089
2090        for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2091                if (path_type_desc[i].type != type)
2092                        continue;
2093
2094                for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2095                        if (path_status_desc[j].status != status)
2096                                continue;
2097
2098                        if (type == IPR_PATH_CFG_IOA_PORT) {
2099                                ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2100                                             path_status_desc[j].desc, path_type_desc[i].desc,
2101                                             cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2102                                             be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2103                        } else {
2104                                if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2105                                        ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2106                                                     path_status_desc[j].desc, path_type_desc[i].desc,
2107                                                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2108                                                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2109                                } else if (cfg->cascaded_expander == 0xff) {
2110                                        ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2111                                                     "WWN=%08X%08X\n", path_status_desc[j].desc,
2112                                                     path_type_desc[i].desc, cfg->phy,
2113                                                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2114                                                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2115                                } else if (cfg->phy == 0xff) {
2116                                        ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2117                                                     "WWN=%08X%08X\n", path_status_desc[j].desc,
2118                                                     path_type_desc[i].desc, cfg->cascaded_expander,
2119                                                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2120                                                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2121                                } else {
2122                                        ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2123                                                     "WWN=%08X%08X\n", path_status_desc[j].desc,
2124                                                     path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2125                                                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2126                                                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2127                                }
2128                        }
2129                        return;
2130                }
2131        }
2132
2133        ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2134                     "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2135                     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2136                     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2137}
2138
2139/**
2140 * ipr_log64_path_elem - Log a fabric path element.
2141 * @hostrcb:    hostrcb struct
2142 * @cfg:                fabric path element struct
2143 *
2144 * Return value:
2145 *      none
2146 **/
2147static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2148                                struct ipr_hostrcb64_config_element *cfg)
2149{
2150        int i, j;
2151        u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2152        u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2153        u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2154        char buffer[IPR_MAX_RES_PATH_LENGTH];
2155
2156        if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2157                return;
2158
2159        for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2160                if (path_type_desc[i].type != type)
2161                        continue;
2162
2163                for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2164                        if (path_status_desc[j].status != status)
2165                                continue;
2166
2167                        ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2168                                     path_status_desc[j].desc, path_type_desc[i].desc,
2169                                     ipr_format_res_path(hostrcb->ioa_cfg,
2170                                        cfg->res_path, buffer, sizeof(buffer)),
2171                                        link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2172                                        be32_to_cpu(cfg->wwid[0]),
2173                                        be32_to_cpu(cfg->wwid[1]));
2174                        return;
2175                }
2176        }
2177        ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2178                     "WWN=%08X%08X\n", cfg->type_status,
2179                     ipr_format_res_path(hostrcb->ioa_cfg,
2180                        cfg->res_path, buffer, sizeof(buffer)),
2181                        link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2182                        be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2183}
2184
2185/**
2186 * ipr_log_fabric_error - Log a fabric error.
2187 * @ioa_cfg:    ioa config struct
2188 * @hostrcb:    hostrcb struct
2189 *
2190 * Return value:
2191 *      none
2192 **/
2193static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2194                                 struct ipr_hostrcb *hostrcb)
2195{
2196        struct ipr_hostrcb_type_20_error *error;
2197        struct ipr_hostrcb_fabric_desc *fabric;
2198        struct ipr_hostrcb_config_element *cfg;
2199        int i, add_len;
2200
2201        error = &hostrcb->hcam.u.error.u.type_20_error;
2202        error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2203        ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2204
2205        add_len = be32_to_cpu(hostrcb->hcam.length) -
2206                (offsetof(struct ipr_hostrcb_error, u) +
2207                 offsetof(struct ipr_hostrcb_type_20_error, desc));
2208
2209        for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2210                ipr_log_fabric_path(hostrcb, fabric);
2211                for_each_fabric_cfg(fabric, cfg)
2212                        ipr_log_path_elem(hostrcb, cfg);
2213
2214                add_len -= be16_to_cpu(fabric->length);
2215                fabric = (struct ipr_hostrcb_fabric_desc *)
2216                        ((unsigned long)fabric + be16_to_cpu(fabric->length));
2217        }
2218
2219        ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2220}
2221
2222/**
2223 * ipr_log_sis64_array_error - Log a sis64 array error.
2224 * @ioa_cfg:    ioa config struct
2225 * @hostrcb:    hostrcb struct
2226 *
2227 * Return value:
2228 *      none
2229 **/
2230static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2231                                      struct ipr_hostrcb *hostrcb)
2232{
2233        int i, num_entries;
2234        struct ipr_hostrcb_type_24_error *error;
2235        struct ipr_hostrcb64_array_data_entry *array_entry;
2236        char buffer[IPR_MAX_RES_PATH_LENGTH];
2237        const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2238
2239        error = &hostrcb->hcam.u.error64.u.type_24_error;
2240
2241        ipr_err_separator;
2242
2243        ipr_err("RAID %s Array Configuration: %s\n",
2244                error->protection_level,
2245                ipr_format_res_path(ioa_cfg, error->last_res_path,
2246                        buffer, sizeof(buffer)));
2247
2248        ipr_err_separator;
2249
2250        array_entry = error->array_member;
2251        num_entries = min_t(u32, error->num_entries,
2252                            ARRAY_SIZE(error->array_member));
2253
2254        for (i = 0; i < num_entries; i++, array_entry++) {
2255
2256                if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2257                        continue;
2258
2259                if (error->exposed_mode_adn == i)
2260                        ipr_err("Exposed Array Member %d:\n", i);
2261                else
2262                        ipr_err("Array Member %d:\n", i);
2263
2264                ipr_err("Array Member %d:\n", i);
2265                ipr_log_ext_vpd(&array_entry->vpd);
2266                ipr_err("Current Location: %s\n",
2267                         ipr_format_res_path(ioa_cfg, array_entry->res_path,
2268                                buffer, sizeof(buffer)));
2269                ipr_err("Expected Location: %s\n",
2270                         ipr_format_res_path(ioa_cfg,
2271                                array_entry->expected_res_path,
2272                                buffer, sizeof(buffer)));
2273
2274                ipr_err_separator;
2275        }
2276}
2277
2278/**
2279 * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2280 * @ioa_cfg:    ioa config struct
2281 * @hostrcb:    hostrcb struct
2282 *
2283 * Return value:
2284 *      none
2285 **/
2286static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2287                                       struct ipr_hostrcb *hostrcb)
2288{
2289        struct ipr_hostrcb_type_30_error *error;
2290        struct ipr_hostrcb64_fabric_desc *fabric;
2291        struct ipr_hostrcb64_config_element *cfg;
2292        int i, add_len;
2293
2294        error = &hostrcb->hcam.u.error64.u.type_30_error;
2295
2296        error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2297        ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2298
2299        add_len = be32_to_cpu(hostrcb->hcam.length) -
2300                (offsetof(struct ipr_hostrcb64_error, u) +
2301                 offsetof(struct ipr_hostrcb_type_30_error, desc));
2302
2303        for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2304                ipr_log64_fabric_path(hostrcb, fabric);
2305                for_each_fabric_cfg(fabric, cfg)
2306                        ipr_log64_path_elem(hostrcb, cfg);
2307
2308                add_len -= be16_to_cpu(fabric->length);
2309                fabric = (struct ipr_hostrcb64_fabric_desc *)
2310                        ((unsigned long)fabric + be16_to_cpu(fabric->length));
2311        }
2312
2313        ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2314}
2315
2316/**
2317 * ipr_log_generic_error - Log an adapter error.
2318 * @ioa_cfg:    ioa config struct
2319 * @hostrcb:    hostrcb struct
2320 *
2321 * Return value:
2322 *      none
2323 **/
2324static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2325                                  struct ipr_hostrcb *hostrcb)
2326{
2327        ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2328                         be32_to_cpu(hostrcb->hcam.length));
2329}
2330
2331/**
2332 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2333 * @ioasc:      IOASC
2334 *
2335 * This function will return the index of into the ipr_error_table
2336 * for the specified IOASC. If the IOASC is not in the table,
2337 * 0 will be returned, which points to the entry used for unknown errors.
2338 *
2339 * Return value:
2340 *      index into the ipr_error_table
2341 **/
2342static u32 ipr_get_error(u32 ioasc)
2343{
2344        int i;
2345
2346        for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2347                if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2348                        return i;
2349
2350        return 0;
2351}
2352
2353/**
2354 * ipr_handle_log_data - Log an adapter error.
2355 * @ioa_cfg:    ioa config struct
2356 * @hostrcb:    hostrcb struct
2357 *
2358 * This function logs an adapter error to the system.
2359 *
2360 * Return value:
2361 *      none
2362 **/
2363static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2364                                struct ipr_hostrcb *hostrcb)
2365{
2366        u32 ioasc;
2367        int error_index;
2368
2369        if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2370                return;
2371
2372        if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2373                dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2374
2375        if (ioa_cfg->sis64)
2376                ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2377        else
2378                ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2379
2380        if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2381            ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2382                /* Tell the midlayer we had a bus reset so it will handle the UA properly */
2383                scsi_report_bus_reset(ioa_cfg->host,
2384                                      hostrcb->hcam.u.error.fd_res_addr.bus);
2385        }
2386
2387        error_index = ipr_get_error(ioasc);
2388
2389        if (!ipr_error_table[error_index].log_hcam)
2390                return;
2391
2392        ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2393
2394        /* Set indication we have logged an error */
2395        ioa_cfg->errors_logged++;
2396
2397        if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2398                return;
2399        if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2400                hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2401
2402        switch (hostrcb->hcam.overlay_id) {
2403        case IPR_HOST_RCB_OVERLAY_ID_2:
2404                ipr_log_cache_error(ioa_cfg, hostrcb);
2405                break;
2406        case IPR_HOST_RCB_OVERLAY_ID_3:
2407                ipr_log_config_error(ioa_cfg, hostrcb);
2408                break;
2409        case IPR_HOST_RCB_OVERLAY_ID_4:
2410        case IPR_HOST_RCB_OVERLAY_ID_6:
2411                ipr_log_array_error(ioa_cfg, hostrcb);
2412                break;
2413        case IPR_HOST_RCB_OVERLAY_ID_7:
2414                ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2415                break;
2416        case IPR_HOST_RCB_OVERLAY_ID_12:
2417                ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2418                break;
2419        case IPR_HOST_RCB_OVERLAY_ID_13:
2420                ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2421                break;
2422        case IPR_HOST_RCB_OVERLAY_ID_14:
2423        case IPR_HOST_RCB_OVERLAY_ID_16:
2424                ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2425                break;
2426        case IPR_HOST_RCB_OVERLAY_ID_17:
2427                ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2428                break;
2429        case IPR_HOST_RCB_OVERLAY_ID_20:
2430                ipr_log_fabric_error(ioa_cfg, hostrcb);
2431                break;
2432        case IPR_HOST_RCB_OVERLAY_ID_23:
2433                ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2434                break;
2435        case IPR_HOST_RCB_OVERLAY_ID_24:
2436        case IPR_HOST_RCB_OVERLAY_ID_26:
2437                ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2438                break;
2439        case IPR_HOST_RCB_OVERLAY_ID_30:
2440                ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2441                break;
2442        case IPR_HOST_RCB_OVERLAY_ID_1:
2443        case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2444        default:
2445                ipr_log_generic_error(ioa_cfg, hostrcb);
2446                break;
2447        }
2448}
2449
2450/**
2451 * ipr_process_error - Op done function for an adapter error log.
2452 * @ipr_cmd:    ipr command struct
2453 *
2454 * This function is the op done function for an error log host
2455 * controlled async from the adapter. It will log the error and
2456 * send the HCAM back to the adapter.
2457 *
2458 * Return value:
2459 *      none
2460 **/
2461static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2462{
2463        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2464        struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2465        u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2466        u32 fd_ioasc;
2467
2468        if (ioa_cfg->sis64)
2469                fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2470        else
2471                fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2472
2473        list_del(&hostrcb->queue);
2474        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
2475
2476        if (!ioasc) {
2477                ipr_handle_log_data(ioa_cfg, hostrcb);
2478                if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2479                        ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2480        } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
2481                dev_err(&ioa_cfg->pdev->dev,
2482                        "Host RCB failed with IOASC: 0x%08X\n", ioasc);
2483        }
2484
2485        ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2486}
2487
2488/**
2489 * ipr_timeout -  An internally generated op has timed out.
2490 * @ipr_cmd:    ipr command struct
2491 *
2492 * This function blocks host requests and initiates an
2493 * adapter reset.
2494 *
2495 * Return value:
2496 *      none
2497 **/
2498static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
2499{
2500        unsigned long lock_flags = 0;
2501        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2502
2503        ENTER;
2504        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2505
2506        ioa_cfg->errors_logged++;
2507        dev_err(&ioa_cfg->pdev->dev,
2508                "Adapter being reset due to command timeout.\n");
2509
2510        if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2511                ioa_cfg->sdt_state = GET_DUMP;
2512
2513        if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2514                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2515
2516        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2517        LEAVE;
2518}
2519
2520/**
2521 * ipr_oper_timeout -  Adapter timed out transitioning to operational
2522 * @ipr_cmd:    ipr command struct
2523 *
2524 * This function blocks host requests and initiates an
2525 * adapter reset.
2526 *
2527 * Return value:
2528 *      none
2529 **/
2530static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
2531{
2532        unsigned long lock_flags = 0;
2533        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2534
2535        ENTER;
2536        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2537
2538        ioa_cfg->errors_logged++;
2539        dev_err(&ioa_cfg->pdev->dev,
2540                "Adapter timed out transitioning to operational.\n");
2541
2542        if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2543                ioa_cfg->sdt_state = GET_DUMP;
2544
2545        if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2546                if (ipr_fastfail)
2547                        ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2548                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2549        }
2550
2551        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2552        LEAVE;
2553}
2554
2555/**
2556 * ipr_find_ses_entry - Find matching SES in SES table
2557 * @res:        resource entry struct of SES
2558 *
2559 * Return value:
2560 *      pointer to SES table entry / NULL on failure
2561 **/
2562static const struct ipr_ses_table_entry *
2563ipr_find_ses_entry(struct ipr_resource_entry *res)
2564{
2565        int i, j, matches;
2566        struct ipr_std_inq_vpids *vpids;
2567        const struct ipr_ses_table_entry *ste = ipr_ses_table;
2568
2569        for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2570                for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2571                        if (ste->compare_product_id_byte[j] == 'X') {
2572                                vpids = &res->std_inq_data.vpids;
2573                                if (vpids->product_id[j] == ste->product_id[j])
2574                                        matches++;
2575                                else
2576                                        break;
2577                        } else
2578                                matches++;
2579                }
2580
2581                if (matches == IPR_PROD_ID_LEN)
2582                        return ste;
2583        }
2584
2585        return NULL;
2586}
2587
2588/**
2589 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2590 * @ioa_cfg:    ioa config struct
2591 * @bus:                SCSI bus
2592 * @bus_width:  bus width
2593 *
2594 * Return value:
2595 *      SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2596 *      For a 2-byte wide SCSI bus, the maximum transfer speed is
2597 *      twice the maximum transfer rate (e.g. for a wide enabled bus,
2598 *      max 160MHz = max 320MB/sec).
2599 **/
2600static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2601{
2602        struct ipr_resource_entry *res;
2603        const struct ipr_ses_table_entry *ste;
2604        u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2605
2606        /* Loop through each config table entry in the config table buffer */
2607        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2608                if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2609                        continue;
2610
2611                if (bus != res->bus)
2612                        continue;
2613
2614                if (!(ste = ipr_find_ses_entry(res)))
2615                        continue;
2616
2617                max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2618        }
2619
2620        return max_xfer_rate;
2621}
2622
2623/**
2624 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2625 * @ioa_cfg:            ioa config struct
2626 * @max_delay:          max delay in micro-seconds to wait
2627 *
2628 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2629 *
2630 * Return value:
2631 *      0 on success / other on failure
2632 **/
2633static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2634{
2635        volatile u32 pcii_reg;
2636        int delay = 1;
2637
2638        /* Read interrupt reg until IOA signals IO Debug Acknowledge */
2639        while (delay < max_delay) {
2640                pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2641
2642                if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2643                        return 0;
2644
2645                /* udelay cannot be used if delay is more than a few milliseconds */
2646                if ((delay / 1000) > MAX_UDELAY_MS)
2647                        mdelay(delay / 1000);
2648                else
2649                        udelay(delay);
2650
2651                delay += delay;
2652        }
2653        return -EIO;
2654}
2655
2656/**
2657 * ipr_get_sis64_dump_data_section - Dump IOA memory
2658 * @ioa_cfg:                    ioa config struct
2659 * @start_addr:                 adapter address to dump
2660 * @dest:                       destination kernel buffer
2661 * @length_in_words:            length to dump in 4 byte words
2662 *
2663 * Return value:
2664 *      0 on success
2665 **/
2666static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2667                                           u32 start_addr,
2668                                           __be32 *dest, u32 length_in_words)
2669{
2670        int i;
2671
2672        for (i = 0; i < length_in_words; i++) {
2673                writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2674                *dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2675                dest++;
2676        }
2677
2678        return 0;
2679}
2680
2681/**
2682 * ipr_get_ldump_data_section - Dump IOA memory
2683 * @ioa_cfg:                    ioa config struct
2684 * @start_addr:                 adapter address to dump
2685 * @dest:                               destination kernel buffer
2686 * @length_in_words:    length to dump in 4 byte words
2687 *
2688 * Return value:
2689 *      0 on success / -EIO on failure
2690 **/
2691static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2692                                      u32 start_addr,
2693                                      __be32 *dest, u32 length_in_words)
2694{
2695        volatile u32 temp_pcii_reg;
2696        int i, delay = 0;
2697
2698        if (ioa_cfg->sis64)
2699                return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2700                                                       dest, length_in_words);
2701
2702        /* Write IOA interrupt reg starting LDUMP state  */
2703        writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2704               ioa_cfg->regs.set_uproc_interrupt_reg32);
2705
2706        /* Wait for IO debug acknowledge */
2707        if (ipr_wait_iodbg_ack(ioa_cfg,
2708                               IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2709                dev_err(&ioa_cfg->pdev->dev,
2710                        "IOA dump long data transfer timeout\n");
2711                return -EIO;
2712        }
2713
2714        /* Signal LDUMP interlocked - clear IO debug ack */
2715        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2716               ioa_cfg->regs.clr_interrupt_reg);
2717
2718        /* Write Mailbox with starting address */
2719        writel(start_addr, ioa_cfg->ioa_mailbox);
2720
2721        /* Signal address valid - clear IOA Reset alert */
2722        writel(IPR_UPROCI_RESET_ALERT,
2723               ioa_cfg->regs.clr_uproc_interrupt_reg32);
2724
2725        for (i = 0; i < length_in_words; i++) {
2726                /* Wait for IO debug acknowledge */
2727                if (ipr_wait_iodbg_ack(ioa_cfg,
2728                                       IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2729                        dev_err(&ioa_cfg->pdev->dev,
2730                                "IOA dump short data transfer timeout\n");
2731                        return -EIO;
2732                }
2733
2734                /* Read data from mailbox and increment destination pointer */
2735                *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2736                dest++;
2737
2738                /* For all but the last word of data, signal data received */
2739                if (i < (length_in_words - 1)) {
2740                        /* Signal dump data received - Clear IO debug Ack */
2741                        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2742                               ioa_cfg->regs.clr_interrupt_reg);
2743                }
2744        }
2745
2746        /* Signal end of block transfer. Set reset alert then clear IO debug ack */
2747        writel(IPR_UPROCI_RESET_ALERT,
2748               ioa_cfg->regs.set_uproc_interrupt_reg32);
2749
2750        writel(IPR_UPROCI_IO_DEBUG_ALERT,
2751               ioa_cfg->regs.clr_uproc_interrupt_reg32);
2752
2753        /* Signal dump data received - Clear IO debug Ack */
2754        writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2755               ioa_cfg->regs.clr_interrupt_reg);
2756
2757        /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2758        while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2759                temp_pcii_reg =
2760                    readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2761
2762                if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2763                        return 0;
2764
2765                udelay(10);
2766                delay += 10;
2767        }
2768
2769        return 0;
2770}
2771
2772#ifdef CONFIG_SCSI_IPR_DUMP
2773/**
2774 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2775 * @ioa_cfg:            ioa config struct
2776 * @pci_address:        adapter address
2777 * @length:                     length of data to copy
2778 *
2779 * Copy data from PCI adapter to kernel buffer.
2780 * Note: length MUST be a 4 byte multiple
2781 * Return value:
2782 *      0 on success / other on failure
2783 **/
2784static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2785                        unsigned long pci_address, u32 length)
2786{
2787        int bytes_copied = 0;
2788        int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2789        __be32 *page;
2790        unsigned long lock_flags = 0;
2791        struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2792
2793        if (ioa_cfg->sis64)
2794                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2795        else
2796                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2797
2798        while (bytes_copied < length &&
2799               (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2800                if (ioa_dump->page_offset >= PAGE_SIZE ||
2801                    ioa_dump->page_offset == 0) {
2802                        page = (__be32 *)__get_free_page(GFP_ATOMIC);
2803
2804                        if (!page) {
2805                                ipr_trace;
2806                                return bytes_copied;
2807                        }
2808
2809                        ioa_dump->page_offset = 0;
2810                        ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2811                        ioa_dump->next_page_index++;
2812                } else
2813                        page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2814
2815                rem_len = length - bytes_copied;
2816                rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2817                cur_len = min(rem_len, rem_page_len);
2818
2819                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2820                if (ioa_cfg->sdt_state == ABORT_DUMP) {
2821                        rc = -EIO;
2822                } else {
2823                        rc = ipr_get_ldump_data_section(ioa_cfg,
2824                                                        pci_address + bytes_copied,
2825                                                        &page[ioa_dump->page_offset / 4],
2826                                                        (cur_len / sizeof(u32)));
2827                }
2828                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2829
2830                if (!rc) {
2831                        ioa_dump->page_offset += cur_len;
2832                        bytes_copied += cur_len;
2833                } else {
2834                        ipr_trace;
2835                        break;
2836                }
2837                schedule();
2838        }
2839
2840        return bytes_copied;
2841}
2842
2843/**
2844 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
2845 * @hdr:        dump entry header struct
2846 *
2847 * Return value:
2848 *      nothing
2849 **/
2850static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
2851{
2852        hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
2853        hdr->num_elems = 1;
2854        hdr->offset = sizeof(*hdr);
2855        hdr->status = IPR_DUMP_STATUS_SUCCESS;
2856}
2857
2858/**
2859 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
2860 * @ioa_cfg:    ioa config struct
2861 * @driver_dump:        driver dump struct
2862 *
2863 * Return value:
2864 *      nothing
2865 **/
2866static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
2867                                   struct ipr_driver_dump *driver_dump)
2868{
2869        struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2870
2871        ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
2872        driver_dump->ioa_type_entry.hdr.len =
2873                sizeof(struct ipr_dump_ioa_type_entry) -
2874                sizeof(struct ipr_dump_entry_header);
2875        driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2876        driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
2877        driver_dump->ioa_type_entry.type = ioa_cfg->type;
2878        driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
2879                (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
2880                ucode_vpd->minor_release[1];
2881        driver_dump->hdr.num_entries++;
2882}
2883
2884/**
2885 * ipr_dump_version_data - Fill in the driver version in the dump.
2886 * @ioa_cfg:    ioa config struct
2887 * @driver_dump:        driver dump struct
2888 *
2889 * Return value:
2890 *      nothing
2891 **/
2892static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
2893                                  struct ipr_driver_dump *driver_dump)
2894{
2895        ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
2896        driver_dump->version_entry.hdr.len =
2897                sizeof(struct ipr_dump_version_entry) -
2898                sizeof(struct ipr_dump_entry_header);
2899        driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2900        driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
2901        strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
2902        driver_dump->hdr.num_entries++;
2903}
2904
2905/**
2906 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
2907 * @ioa_cfg:    ioa config struct
2908 * @driver_dump:        driver dump struct
2909 *
2910 * Return value:
2911 *      nothing
2912 **/
2913static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
2914                                   struct ipr_driver_dump *driver_dump)
2915{
2916        ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
2917        driver_dump->trace_entry.hdr.len =
2918                sizeof(struct ipr_dump_trace_entry) -
2919                sizeof(struct ipr_dump_entry_header);
2920        driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2921        driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
2922        memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
2923        driver_dump->hdr.num_entries++;
2924}
2925
2926/**
2927 * ipr_dump_location_data - Fill in the IOA location in the dump.
2928 * @ioa_cfg:    ioa config struct
2929 * @driver_dump:        driver dump struct
2930 *
2931 * Return value:
2932 *      nothing
2933 **/
2934static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
2935                                   struct ipr_driver_dump *driver_dump)
2936{
2937        ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
2938        driver_dump->location_entry.hdr.len =
2939                sizeof(struct ipr_dump_location_entry) -
2940                sizeof(struct ipr_dump_entry_header);
2941        driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2942        driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
2943        strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
2944        driver_dump->hdr.num_entries++;
2945}
2946
2947/**
2948 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
2949 * @ioa_cfg:    ioa config struct
2950 * @dump:               dump struct
2951 *
2952 * Return value:
2953 *      nothing
2954 **/
2955static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
2956{
2957        unsigned long start_addr, sdt_word;
2958        unsigned long lock_flags = 0;
2959        struct ipr_driver_dump *driver_dump = &dump->driver_dump;
2960        struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
2961        u32 num_entries, max_num_entries, start_off, end_off;
2962        u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
2963        struct ipr_sdt *sdt;
2964        int valid = 1;
2965        int i;
2966
2967        ENTER;
2968
2969        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2970
2971        if (ioa_cfg->sdt_state != READ_DUMP) {
2972                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2973                return;
2974        }
2975
2976        if (ioa_cfg->sis64) {
2977                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2978                ssleep(IPR_DUMP_DELAY_SECONDS);
2979                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2980        }
2981
2982        start_addr = readl(ioa_cfg->ioa_mailbox);
2983
2984        if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
2985                dev_err(&ioa_cfg->pdev->dev,
2986                        "Invalid dump table format: %lx\n", start_addr);
2987                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2988                return;
2989        }
2990
2991        dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
2992
2993        driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
2994
2995        /* Initialize the overall dump header */
2996        driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
2997        driver_dump->hdr.num_entries = 1;
2998        driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
2999        driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
3000        driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
3001        driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
3002
3003        ipr_dump_version_data(ioa_cfg, driver_dump);
3004        ipr_dump_location_data(ioa_cfg, driver_dump);
3005        ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
3006        ipr_dump_trace_data(ioa_cfg, driver_dump);
3007
3008        /* Update dump_header */
3009        driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
3010
3011        /* IOA Dump entry */
3012        ipr_init_dump_entry_hdr(&ioa_dump->hdr);
3013        ioa_dump->hdr.len = 0;
3014        ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
3015        ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
3016
3017        /* First entries in sdt are actually a list of dump addresses and
3018         lengths to gather the real dump data.  sdt represents the pointer
3019         to the ioa generated dump table.  Dump data will be extracted based
3020         on entries in this table */
3021        sdt = &ioa_dump->sdt;
3022
3023        if (ioa_cfg->sis64) {
3024                max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
3025                max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
3026        } else {
3027                max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
3028                max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
3029        }
3030
3031        bytes_to_copy = offsetof(struct ipr_sdt, entry) +
3032                        (max_num_entries * sizeof(struct ipr_sdt_entry));
3033        rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
3034                                        bytes_to_copy / sizeof(__be32));
3035
3036        /* Smart Dump table is ready to use and the first entry is valid */
3037        if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
3038            (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
3039                dev_err(&ioa_cfg->pdev->dev,
3040                        "Dump of IOA failed. Dump table not valid: %d, %X.\n",
3041                        rc, be32_to_cpu(sdt->hdr.state));
3042                driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
3043                ioa_cfg->sdt_state = DUMP_OBTAINED;
3044                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3045                return;
3046        }
3047
3048        num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
3049
3050        if (num_entries > max_num_entries)
3051                num_entries = max_num_entries;
3052
3053        /* Update dump length to the actual data to be copied */
3054        dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
3055        if (ioa_cfg->sis64)
3056                dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
3057        else
3058                dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
3059
3060        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3061
3062        for (i = 0; i < num_entries; i++) {
3063                if (ioa_dump->hdr.len > max_dump_size) {
3064                        driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3065                        break;
3066                }
3067
3068                if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3069                        sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3070                        if (ioa_cfg->sis64)
3071                                bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3072                        else {
3073                                start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3074                                end_off = be32_to_cpu(sdt->entry[i].end_token);
3075
3076                                if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3077                                        bytes_to_copy = end_off - start_off;
3078                                else
3079                                        valid = 0;
3080                        }
3081                        if (valid) {
3082                                if (bytes_to_copy > max_dump_size) {
3083                                        sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3084                                        continue;
3085                                }
3086
3087                                /* Copy data from adapter to driver buffers */
3088                                bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3089                                                            bytes_to_copy);
3090
3091                                ioa_dump->hdr.len += bytes_copied;
3092
3093                                if (bytes_copied != bytes_to_copy) {
3094                                        driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3095                                        break;
3096                                }
3097                        }
3098                }
3099        }
3100
3101        dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3102
3103        /* Update dump_header */
3104        driver_dump->hdr.len += ioa_dump->hdr.len;
3105        wmb();
3106        ioa_cfg->sdt_state = DUMP_OBTAINED;
3107        LEAVE;
3108}
3109
3110#else
3111#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
3112#endif
3113
3114/**
3115 * ipr_release_dump - Free adapter dump memory
3116 * @kref:       kref struct
3117 *
3118 * Return value:
3119 *      nothing
3120 **/
3121static void ipr_release_dump(struct kref *kref)
3122{
3123        struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
3124        struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3125        unsigned long lock_flags = 0;
3126        int i;
3127
3128        ENTER;
3129        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3130        ioa_cfg->dump = NULL;
3131        ioa_cfg->sdt_state = INACTIVE;
3132        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3133
3134        for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3135                free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3136
3137        vfree(dump->ioa_dump.ioa_data);
3138        kfree(dump);
3139        LEAVE;
3140}
3141
3142/**
3143 * ipr_worker_thread - Worker thread
3144 * @work:               ioa config struct
3145 *
3146 * Called at task level from a work thread. This function takes care
3147 * of adding and removing device from the mid-layer as configuration
3148 * changes are detected by the adapter.
3149 *
3150 * Return value:
3151 *      nothing
3152 **/
3153static void ipr_worker_thread(struct work_struct *work)
3154{
3155        unsigned long lock_flags;
3156        struct ipr_resource_entry *res;
3157        struct scsi_device *sdev;
3158        struct ipr_dump *dump;
3159        struct ipr_ioa_cfg *ioa_cfg =
3160                container_of(work, struct ipr_ioa_cfg, work_q);
3161        u8 bus, target, lun;
3162        int did_work;
3163
3164        ENTER;
3165        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3166
3167        if (ioa_cfg->sdt_state == READ_DUMP) {
3168                dump = ioa_cfg->dump;
3169                if (!dump) {
3170                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3171                        return;
3172                }
3173                kref_get(&dump->kref);
3174                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3175                ipr_get_ioa_dump(ioa_cfg, dump);
3176                kref_put(&dump->kref, ipr_release_dump);
3177
3178                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3179                if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
3180                        ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3181                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3182                return;
3183        }
3184
3185restart:
3186        do {
3187                did_work = 0;
3188                if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
3189                    !ioa_cfg->allow_ml_add_del) {
3190                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3191                        return;
3192                }
3193
3194                list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3195                        if (res->del_from_ml && res->sdev) {
3196                                did_work = 1;
3197                                sdev = res->sdev;
3198                                if (!scsi_device_get(sdev)) {
3199                                        if (!res->add_to_ml)
3200                                                list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3201                                        else
3202                                                res->del_from_ml = 0;
3203                                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3204                                        scsi_remove_device(sdev);
3205                                        scsi_device_put(sdev);
3206                                        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3207                                }
3208                                break;
3209                        }
3210                }
3211        } while (did_work);
3212
3213        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3214                if (res->add_to_ml) {
3215                        bus = res->bus;
3216                        target = res->target;
3217                        lun = res->lun;
3218                        res->add_to_ml = 0;
3219                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3220                        scsi_add_device(ioa_cfg->host, bus, target, lun);
3221                        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3222                        goto restart;
3223                }
3224        }
3225
3226        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3227        kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3228        LEAVE;
3229}
3230
3231#ifdef CONFIG_SCSI_IPR_TRACE
3232/**
3233 * ipr_read_trace - Dump the adapter trace
3234 * @filp:               open sysfs file
3235 * @kobj:               kobject struct
3236 * @bin_attr:           bin_attribute struct
3237 * @buf:                buffer
3238 * @off:                offset
3239 * @count:              buffer size
3240 *
3241 * Return value:
3242 *      number of bytes printed to buffer
3243 **/
3244static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3245                              struct bin_attribute *bin_attr,
3246                              char *buf, loff_t off, size_t count)
3247{
3248        struct device *dev = container_of(kobj, struct device, kobj);
3249        struct Scsi_Host *shost = class_to_shost(dev);
3250        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3251        unsigned long lock_flags = 0;
3252        ssize_t ret;
3253
3254        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3255        ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3256                                IPR_TRACE_SIZE);
3257        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3258
3259        return ret;
3260}
3261
3262static struct bin_attribute ipr_trace_attr = {
3263        .attr = {
3264                .name = "trace",
3265                .mode = S_IRUGO,
3266        },
3267        .size = 0,
3268        .read = ipr_read_trace,
3269};
3270#endif
3271
3272/**
3273 * ipr_show_fw_version - Show the firmware version
3274 * @dev:        class device struct
3275 * @buf:        buffer
3276 *
3277 * Return value:
3278 *      number of bytes printed to buffer
3279 **/
3280static ssize_t ipr_show_fw_version(struct device *dev,
3281                                   struct device_attribute *attr, char *buf)
3282{
3283        struct Scsi_Host *shost = class_to_shost(dev);
3284        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3285        struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3286        unsigned long lock_flags = 0;
3287        int len;
3288
3289        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3290        len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3291                       ucode_vpd->major_release, ucode_vpd->card_type,
3292                       ucode_vpd->minor_release[0],
3293                       ucode_vpd->minor_release[1]);
3294        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3295        return len;
3296}
3297
3298static struct device_attribute ipr_fw_version_attr = {
3299        .attr = {
3300                .name =         "fw_version",
3301                .mode =         S_IRUGO,
3302        },
3303        .show = ipr_show_fw_version,
3304};
3305
3306/**
3307 * ipr_show_log_level - Show the adapter's error logging level
3308 * @dev:        class device struct
3309 * @buf:        buffer
3310 *
3311 * Return value:
3312 *      number of bytes printed to buffer
3313 **/
3314static ssize_t ipr_show_log_level(struct device *dev,
3315                                   struct device_attribute *attr, char *buf)
3316{
3317        struct Scsi_Host *shost = class_to_shost(dev);
3318        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3319        unsigned long lock_flags = 0;
3320        int len;
3321
3322        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3323        len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3324        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3325        return len;
3326}
3327
3328/**
3329 * ipr_store_log_level - Change the adapter's error logging level
3330 * @dev:        class device struct
3331 * @buf:        buffer
3332 *
3333 * Return value:
3334 *      number of bytes printed to buffer
3335 **/
3336static ssize_t ipr_store_log_level(struct device *dev,
3337                                   struct device_attribute *attr,
3338                                   const char *buf, size_t count)
3339{
3340        struct Scsi_Host *shost = class_to_shost(dev);
3341        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3342        unsigned long lock_flags = 0;
3343
3344        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3345        ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3346        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3347        return strlen(buf);
3348}
3349
3350static struct device_attribute ipr_log_level_attr = {
3351        .attr = {
3352                .name =         "log_level",
3353                .mode =         S_IRUGO | S_IWUSR,
3354        },
3355        .show = ipr_show_log_level,
3356        .store = ipr_store_log_level
3357};
3358
3359/**
3360 * ipr_store_diagnostics - IOA Diagnostics interface
3361 * @dev:        device struct
3362 * @buf:        buffer
3363 * @count:      buffer size
3364 *
3365 * This function will reset the adapter and wait a reasonable
3366 * amount of time for any errors that the adapter might log.
3367 *
3368 * Return value:
3369 *      count on success / other on failure
3370 **/
3371static ssize_t ipr_store_diagnostics(struct device *dev,
3372                                     struct device_attribute *attr,
3373                                     const char *buf, size_t count)
3374{
3375        struct Scsi_Host *shost = class_to_shost(dev);
3376        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3377        unsigned long lock_flags = 0;
3378        int rc = count;
3379
3380        if (!capable(CAP_SYS_ADMIN))
3381                return -EACCES;
3382
3383        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3384        while (ioa_cfg->in_reset_reload) {
3385                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3386                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3387                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3388        }
3389
3390        ioa_cfg->errors_logged = 0;
3391        ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3392
3393        if (ioa_cfg->in_reset_reload) {
3394                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3395                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3396
3397                /* Wait for a second for any errors to be logged */
3398                msleep(1000);
3399        } else {
3400                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3401                return -EIO;
3402        }
3403
3404        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3405        if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3406                rc = -EIO;
3407        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3408
3409        return rc;
3410}
3411
3412static struct device_attribute ipr_diagnostics_attr = {
3413        .attr = {
3414                .name =         "run_diagnostics",
3415                .mode =         S_IWUSR,
3416        },
3417        .store = ipr_store_diagnostics
3418};
3419
3420/**
3421 * ipr_show_adapter_state - Show the adapter's state
3422 * @class_dev:  device struct
3423 * @buf:        buffer
3424 *
3425 * Return value:
3426 *      number of bytes printed to buffer
3427 **/
3428static ssize_t ipr_show_adapter_state(struct device *dev,
3429                                      struct device_attribute *attr, char *buf)
3430{
3431        struct Scsi_Host *shost = class_to_shost(dev);
3432        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3433        unsigned long lock_flags = 0;
3434        int len;
3435
3436        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3437        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
3438                len = snprintf(buf, PAGE_SIZE, "offline\n");
3439        else
3440                len = snprintf(buf, PAGE_SIZE, "online\n");
3441        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3442        return len;
3443}
3444
3445/**
3446 * ipr_store_adapter_state - Change adapter state
3447 * @dev:        device struct
3448 * @buf:        buffer
3449 * @count:      buffer size
3450 *
3451 * This function will change the adapter's state.
3452 *
3453 * Return value:
3454 *      count on success / other on failure
3455 **/
3456static ssize_t ipr_store_adapter_state(struct device *dev,
3457                                       struct device_attribute *attr,
3458                                       const char *buf, size_t count)
3459{
3460        struct Scsi_Host *shost = class_to_shost(dev);
3461        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3462        unsigned long lock_flags;
3463        int result = count, i;
3464
3465        if (!capable(CAP_SYS_ADMIN))
3466                return -EACCES;
3467
3468        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3469        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead &&
3470            !strncmp(buf, "online", 6)) {
3471                for (i = 0; i < ioa_cfg->hrrq_num; i++) {
3472                        spin_lock(&ioa_cfg->hrrq[i]._lock);
3473                        ioa_cfg->hrrq[i].ioa_is_dead = 0;
3474                        spin_unlock(&ioa_cfg->hrrq[i]._lock);
3475                }
3476                wmb();
3477                ioa_cfg->reset_retries = 0;
3478                ioa_cfg->in_ioa_bringdown = 0;
3479                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3480        }
3481        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3482        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3483
3484        return result;
3485}
3486
3487static struct device_attribute ipr_ioa_state_attr = {
3488        .attr = {
3489                .name =         "online_state",
3490                .mode =         S_IRUGO | S_IWUSR,
3491        },
3492        .show = ipr_show_adapter_state,
3493        .store = ipr_store_adapter_state
3494};
3495
3496/**
3497 * ipr_store_reset_adapter - Reset the adapter
3498 * @dev:        device struct
3499 * @buf:        buffer
3500 * @count:      buffer size
3501 *
3502 * This function will reset the adapter.
3503 *
3504 * Return value:
3505 *      count on success / other on failure
3506 **/
3507static ssize_t ipr_store_reset_adapter(struct device *dev,
3508                                       struct device_attribute *attr,
3509                                       const char *buf, size_t count)
3510{
3511        struct Scsi_Host *shost = class_to_shost(dev);
3512        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3513        unsigned long lock_flags;
3514        int result = count;
3515
3516        if (!capable(CAP_SYS_ADMIN))
3517                return -EACCES;
3518
3519        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3520        if (!ioa_cfg->in_reset_reload)
3521                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3522        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3523        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3524
3525        return result;
3526}
3527
3528static struct device_attribute ipr_ioa_reset_attr = {
3529        .attr = {
3530                .name =         "reset_host",
3531                .mode =         S_IWUSR,
3532        },
3533        .store = ipr_store_reset_adapter
3534};
3535
3536static int ipr_iopoll(struct blk_iopoll *iop, int budget);
3537 /**
3538 * ipr_show_iopoll_weight - Show ipr polling mode
3539 * @dev:        class device struct
3540 * @buf:        buffer
3541 *
3542 * Return value:
3543 *      number of bytes printed to buffer
3544 **/
3545static ssize_t ipr_show_iopoll_weight(struct device *dev,
3546                                   struct device_attribute *attr, char *buf)
3547{
3548        struct Scsi_Host *shost = class_to_shost(dev);
3549        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3550        unsigned long lock_flags = 0;
3551        int len;
3552
3553        spin_lock_irqsave(shost->host_lock, lock_flags);
3554        len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight);
3555        spin_unlock_irqrestore(shost->host_lock, lock_flags);
3556
3557        return len;
3558}
3559
3560/**
3561 * ipr_store_iopoll_weight - Change the adapter's polling mode
3562 * @dev:        class device struct
3563 * @buf:        buffer
3564 *
3565 * Return value:
3566 *      number of bytes printed to buffer
3567 **/
3568static ssize_t ipr_store_iopoll_weight(struct device *dev,
3569                                        struct device_attribute *attr,
3570                                        const char *buf, size_t count)
3571{
3572        struct Scsi_Host *shost = class_to_shost(dev);
3573        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3574        unsigned long user_iopoll_weight;
3575        unsigned long lock_flags = 0;
3576        int i;
3577
3578        if (!ioa_cfg->sis64) {
3579                dev_info(&ioa_cfg->pdev->dev, "blk-iopoll not supported on this adapter\n");
3580                return -EINVAL;
3581        }
3582        if (kstrtoul(buf, 10, &user_iopoll_weight))
3583                return -EINVAL;
3584
3585        if (user_iopoll_weight > 256) {
3586                dev_info(&ioa_cfg->pdev->dev, "Invalid blk-iopoll weight. It must be less than 256\n");
3587                return -EINVAL;
3588        }
3589
3590        if (user_iopoll_weight == ioa_cfg->iopoll_weight) {
3591                dev_info(&ioa_cfg->pdev->dev, "Current blk-iopoll weight has the same weight\n");
3592                return strlen(buf);
3593        }
3594
3595        if (blk_iopoll_enabled && ioa_cfg->iopoll_weight &&
3596                        ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3597                for (i = 1; i < ioa_cfg->hrrq_num; i++)
3598                        blk_iopoll_disable(&ioa_cfg->hrrq[i].iopoll);
3599        }
3600
3601        spin_lock_irqsave(shost->host_lock, lock_flags);
3602        ioa_cfg->iopoll_weight = user_iopoll_weight;
3603        if (blk_iopoll_enabled && ioa_cfg->iopoll_weight &&
3604                        ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
3605                for (i = 1; i < ioa_cfg->hrrq_num; i++) {
3606                        blk_iopoll_init(&ioa_cfg->hrrq[i].iopoll,
3607                                        ioa_cfg->iopoll_weight, ipr_iopoll);
3608                        blk_iopoll_enable(&ioa_cfg->hrrq[i].iopoll);
3609                }
3610        }
3611        spin_unlock_irqrestore(shost->host_lock, lock_flags);
3612
3613        return strlen(buf);
3614}
3615
3616static struct device_attribute ipr_iopoll_weight_attr = {
3617        .attr = {
3618                .name =         "iopoll_weight",
3619                .mode =         S_IRUGO | S_IWUSR,
3620        },
3621        .show = ipr_show_iopoll_weight,
3622        .store = ipr_store_iopoll_weight
3623};
3624
3625/**
3626 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3627 * @buf_len:            buffer length
3628 *
3629 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3630 * list to use for microcode download
3631 *
3632 * Return value:
3633 *      pointer to sglist / NULL on failure
3634 **/
3635static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3636{
3637        int sg_size, order, bsize_elem, num_elem, i, j;
3638        struct ipr_sglist *sglist;
3639        struct scatterlist *scatterlist;
3640        struct page *page;
3641
3642        /* Get the minimum size per scatter/gather element */
3643        sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3644
3645        /* Get the actual size per element */
3646        order = get_order(sg_size);
3647
3648        /* Determine the actual number of bytes per element */
3649        bsize_elem = PAGE_SIZE * (1 << order);
3650
3651        /* Determine the actual number of sg entries needed */
3652        if (buf_len % bsize_elem)
3653                num_elem = (buf_len / bsize_elem) + 1;
3654        else
3655                num_elem = buf_len / bsize_elem;
3656
3657        /* Allocate a scatter/gather list for the DMA */
3658        sglist = kzalloc(sizeof(struct ipr_sglist) +
3659                         (sizeof(struct scatterlist) * (num_elem - 1)),
3660                         GFP_KERNEL);
3661
3662        if (sglist == NULL) {
3663                ipr_trace;
3664                return NULL;
3665        }
3666
3667        scatterlist = sglist->scatterlist;
3668        sg_init_table(scatterlist, num_elem);
3669
3670        sglist->order = order;
3671        sglist->num_sg = num_elem;
3672
3673        /* Allocate a bunch of sg elements */
3674        for (i = 0; i < num_elem; i++) {
3675                page = alloc_pages(GFP_KERNEL, order);
3676                if (!page) {
3677                        ipr_trace;
3678
3679                        /* Free up what we already allocated */
3680                        for (j = i - 1; j >= 0; j--)
3681                                __free_pages(sg_page(&scatterlist[j]), order);
3682                        kfree(sglist);
3683                        return NULL;
3684                }
3685
3686                sg_set_page(&scatterlist[i], page, 0, 0);
3687        }
3688
3689        return sglist;
3690}
3691
3692/**
3693 * ipr_free_ucode_buffer - Frees a microcode download buffer
3694 * @p_dnld:             scatter/gather list pointer
3695 *
3696 * Free a DMA'able ucode download buffer previously allocated with
3697 * ipr_alloc_ucode_buffer
3698 *
3699 * Return value:
3700 *      nothing
3701 **/
3702static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3703{
3704        int i;
3705
3706        for (i = 0; i < sglist->num_sg; i++)
3707                __free_pages(sg_page(&sglist->scatterlist[i]), sglist->order);
3708
3709        kfree(sglist);
3710}
3711
3712/**
3713 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3714 * @sglist:             scatter/gather list pointer
3715 * @buffer:             buffer pointer
3716 * @len:                buffer length
3717 *
3718 * Copy a microcode image from a user buffer into a buffer allocated by
3719 * ipr_alloc_ucode_buffer
3720 *
3721 * Return value:
3722 *      0 on success / other on failure
3723 **/
3724static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3725                                 u8 *buffer, u32 len)
3726{
3727        int bsize_elem, i, result = 0;
3728        struct scatterlist *scatterlist;
3729        void *kaddr;
3730
3731        /* Determine the actual number of bytes per element */
3732        bsize_elem = PAGE_SIZE * (1 << sglist->order);
3733
3734        scatterlist = sglist->scatterlist;
3735
3736        for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3737                struct page *page = sg_page(&scatterlist[i]);
3738
3739                kaddr = kmap(page);
3740                memcpy(kaddr, buffer, bsize_elem);
3741                kunmap(page);
3742
3743                scatterlist[i].length = bsize_elem;
3744
3745                if (result != 0) {
3746                        ipr_trace;
3747                        return result;
3748                }
3749        }
3750
3751        if (len % bsize_elem) {
3752                struct page *page = sg_page(&scatterlist[i]);
3753
3754                kaddr = kmap(page);
3755                memcpy(kaddr, buffer, len % bsize_elem);
3756                kunmap(page);
3757
3758                scatterlist[i].length = len % bsize_elem;
3759        }
3760
3761        sglist->buffer_len = len;
3762        return result;
3763}
3764
3765/**
3766 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3767 * @ipr_cmd:            ipr command struct
3768 * @sglist:             scatter/gather list
3769 *
3770 * Builds a microcode download IOA data list (IOADL).
3771 *
3772 **/
3773static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3774                                    struct ipr_sglist *sglist)
3775{
3776        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3777        struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3778        struct scatterlist *scatterlist = sglist->scatterlist;
3779        int i;
3780
3781        ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3782        ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3783        ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3784
3785        ioarcb->ioadl_len =
3786                cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3787        for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3788                ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3789                ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
3790                ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
3791        }
3792
3793        ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3794}
3795
3796/**
3797 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3798 * @ipr_cmd:    ipr command struct
3799 * @sglist:             scatter/gather list
3800 *
3801 * Builds a microcode download IOA data list (IOADL).
3802 *
3803 **/
3804static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3805                                  struct ipr_sglist *sglist)
3806{
3807        struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3808        struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3809        struct scatterlist *scatterlist = sglist->scatterlist;
3810        int i;
3811
3812        ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3813        ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3814        ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3815
3816        ioarcb->ioadl_len =
3817                cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3818
3819        for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3820                ioadl[i].flags_and_data_len =
3821                        cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
3822                ioadl[i].address =
3823                        cpu_to_be32(sg_dma_address(&scatterlist[i]));
3824        }
3825
3826        ioadl[i-1].flags_and_data_len |=
3827                cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3828}
3829
3830/**
3831 * ipr_update_ioa_ucode - Update IOA's microcode
3832 * @ioa_cfg:    ioa config struct
3833 * @sglist:             scatter/gather list
3834 *
3835 * Initiate an adapter reset to update the IOA's microcode
3836 *
3837 * Return value:
3838 *      0 on success / -EIO on failure
3839 **/
3840static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
3841                                struct ipr_sglist *sglist)
3842{
3843        unsigned long lock_flags;
3844
3845        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3846        while (ioa_cfg->in_reset_reload) {
3847                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3848                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3849                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3850        }
3851
3852        if (ioa_cfg->ucode_sglist) {
3853                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3854                dev_err(&ioa_cfg->pdev->dev,
3855                        "Microcode download already in progress\n");
3856                return -EIO;
3857        }
3858
3859        sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
3860                                        sglist->num_sg, DMA_TO_DEVICE);
3861
3862        if (!sglist->num_dma_sg) {
3863                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3864                dev_err(&ioa_cfg->pdev->dev,
3865                        "Failed to map microcode download buffer!\n");
3866                return -EIO;
3867        }
3868
3869        ioa_cfg->ucode_sglist = sglist;
3870        ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3871        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3872        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3873
3874        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3875        ioa_cfg->ucode_sglist = NULL;
3876        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3877        return 0;
3878}
3879
3880/**
3881 * ipr_store_update_fw - Update the firmware on the adapter
3882 * @class_dev:  device struct
3883 * @buf:        buffer
3884 * @count:      buffer size
3885 *
3886 * This function will update the firmware on the adapter.
3887 *
3888 * Return value:
3889 *      count on success / other on failure
3890 **/
3891static ssize_t ipr_store_update_fw(struct device *dev,
3892                                   struct device_attribute *attr,
3893                                   const char *buf, size_t count)
3894{
3895        struct Scsi_Host *shost = class_to_shost(dev);
3896        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3897        struct ipr_ucode_image_header *image_hdr;
3898        const struct firmware *fw_entry;
3899        struct ipr_sglist *sglist;
3900        char fname[100];
3901        char *src;
3902        int len, result, dnld_size;
3903
3904        if (!capable(CAP_SYS_ADMIN))
3905                return -EACCES;
3906
3907        len = snprintf(fname, 99, "%s", buf);
3908        fname[len-1] = '\0';
3909
3910        if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
3911                dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
3912                return -EIO;
3913        }
3914
3915        image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
3916
3917        src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
3918        dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
3919        sglist = ipr_alloc_ucode_buffer(dnld_size);
3920
3921        if (!sglist) {
3922                dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
3923                release_firmware(fw_entry);
3924                return -ENOMEM;
3925        }
3926
3927        result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
3928
3929        if (result) {
3930                dev_err(&ioa_cfg->pdev->dev,
3931                        "Microcode buffer copy to DMA buffer failed\n");
3932                goto out;
3933        }
3934
3935        ipr_info("Updating microcode, please be patient.  This may take up to 30 minutes.\n");
3936
3937        result = ipr_update_ioa_ucode(ioa_cfg, sglist);
3938
3939        if (!result)
3940                result = count;
3941out:
3942        ipr_free_ucode_buffer(sglist);
3943        release_firmware(fw_entry);
3944        return result;
3945}
3946
3947static struct device_attribute ipr_update_fw_attr = {
3948        .attr = {
3949                .name =         "update_fw",
3950                .mode =         S_IWUSR,
3951        },
3952        .store = ipr_store_update_fw
3953};
3954
3955/**
3956 * ipr_show_fw_type - Show the adapter's firmware type.
3957 * @dev:        class device struct
3958 * @buf:        buffer
3959 *
3960 * Return value:
3961 *      number of bytes printed to buffer
3962 **/
3963static ssize_t ipr_show_fw_type(struct device *dev,
3964                                struct device_attribute *attr, char *buf)
3965{
3966        struct Scsi_Host *shost = class_to_shost(dev);
3967        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3968        unsigned long lock_flags = 0;
3969        int len;
3970
3971        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3972        len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
3973        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3974        return len;
3975}
3976
3977static struct device_attribute ipr_ioa_fw_type_attr = {
3978        .attr = {
3979                .name =         "fw_type",
3980                .mode =         S_IRUGO,
3981        },
3982        .show = ipr_show_fw_type
3983};
3984
3985static struct device_attribute *ipr_ioa_attrs[] = {
3986        &ipr_fw_version_attr,
3987        &ipr_log_level_attr,
3988        &ipr_diagnostics_attr,
3989        &ipr_ioa_state_attr,
3990        &ipr_ioa_reset_attr,
3991        &ipr_update_fw_attr,
3992        &ipr_ioa_fw_type_attr,
3993        &ipr_iopoll_weight_attr,
3994        NULL,
3995};
3996
3997#ifdef CONFIG_SCSI_IPR_DUMP
3998/**
3999 * ipr_read_dump - Dump the adapter
4000 * @filp:               open sysfs file
4001 * @kobj:               kobject struct
4002 * @bin_attr:           bin_attribute struct
4003 * @buf:                buffer
4004 * @off:                offset
4005 * @count:              buffer size
4006 *
4007 * Return value:
4008 *      number of bytes printed to buffer
4009 **/
4010static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
4011                             struct bin_attribute *bin_attr,
4012                             char *buf, loff_t off, size_t count)
4013{
4014        struct device *cdev = container_of(kobj, struct device, kobj);
4015        struct Scsi_Host *shost = class_to_shost(cdev);
4016        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4017        struct ipr_dump *dump;
4018        unsigned long lock_flags = 0;
4019        char *src;
4020        int len, sdt_end;
4021        size_t rc = count;
4022
4023        if (!capable(CAP_SYS_ADMIN))
4024                return -EACCES;
4025
4026        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4027        dump = ioa_cfg->dump;
4028
4029        if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
4030                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4031                return 0;
4032        }
4033        kref_get(&dump->kref);
4034        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4035
4036        if (off > dump->driver_dump.hdr.len) {
4037                kref_put(&dump->kref, ipr_release_dump);
4038                return 0;
4039        }
4040
4041        if (off + count > dump->driver_dump.hdr.len) {
4042                count = dump->driver_dump.hdr.len - off;
4043                rc = count;
4044        }
4045
4046        if (count && off < sizeof(dump->driver_dump)) {
4047                if (off + count > sizeof(dump->driver_dump))
4048                        len = sizeof(dump->driver_dump) - off;
4049                else
4050                        len = count;
4051                src = (u8 *)&dump->driver_dump + off;
4052                memcpy(buf, src, len);
4053                buf += len;
4054                off += len;
4055                count -= len;
4056        }
4057
4058        off -= sizeof(dump->driver_dump);
4059
4060        if (ioa_cfg->sis64)
4061                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4062                          (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
4063                           sizeof(struct ipr_sdt_entry));
4064        else
4065                sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
4066                          (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
4067
4068        if (count && off < sdt_end) {
4069                if (off + count > sdt_end)
4070                        len = sdt_end - off;
4071                else
4072                        len = count;
4073                src = (u8 *)&dump->ioa_dump + off;
4074                memcpy(buf, src, len);
4075                buf += len;
4076                off += len;
4077                count -= len;
4078        }
4079
4080        off -= sdt_end;
4081
4082        while (count) {
4083                if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
4084                        len = PAGE_ALIGN(off) - off;
4085                else
4086                        len = count;
4087                src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
4088                src += off & ~PAGE_MASK;
4089                memcpy(buf, src, len);
4090                buf += len;
4091                off += len;
4092                count -= len;
4093        }
4094
4095        kref_put(&dump->kref, ipr_release_dump);
4096        return rc;
4097}
4098
4099/**
4100 * ipr_alloc_dump - Prepare for adapter dump
4101 * @ioa_cfg:    ioa config struct
4102 *
4103 * Return value:
4104 *      0 on success / other on failure
4105 **/
4106static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
4107{
4108        struct ipr_dump *dump;
4109        __be32 **ioa_data;
4110        unsigned long lock_flags = 0;
4111
4112        dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
4113
4114        if (!dump) {
4115                ipr_err("Dump memory allocation failed\n");
4116                return -ENOMEM;
4117        }
4118
4119        if (ioa_cfg->sis64)
4120                ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
4121        else
4122                ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
4123
4124        if (!ioa_data) {
4125                ipr_err("Dump memory allocation failed\n");
4126                kfree(dump);
4127                return -ENOMEM;
4128        }
4129
4130        dump->ioa_dump.ioa_data = ioa_data;
4131
4132        kref_init(&dump->kref);
4133        dump->ioa_cfg = ioa_cfg;
4134
4135        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4136
4137        if (INACTIVE != ioa_cfg->sdt_state) {
4138                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4139                vfree(dump->ioa_dump.ioa_data);
4140                kfree(dump);
4141                return 0;
4142        }
4143
4144        ioa_cfg->dump = dump;
4145        ioa_cfg->sdt_state = WAIT_FOR_DUMP;
4146        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
4147                ioa_cfg->dump_taken = 1;
4148                schedule_work(&ioa_cfg->work_q);
4149        }
4150        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4151
4152        return 0;
4153}
4154
4155/**
4156 * ipr_free_dump - Free adapter dump memory
4157 * @ioa_cfg:    ioa config struct
4158 *
4159 * Return value:
4160 *      0 on success / other on failure
4161 **/
4162static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4163{
4164        struct ipr_dump *dump;
4165        unsigned long lock_flags = 0;
4166
4167        ENTER;
4168
4169        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4170        dump = ioa_cfg->dump;
4171        if (!dump) {
4172                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4173                return 0;
4174        }
4175
4176        ioa_cfg->dump = NULL;
4177        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4178
4179        kref_put(&dump->kref, ipr_release_dump);
4180
4181        LEAVE;
4182        return 0;
4183}
4184
4185/**
4186 * ipr_write_dump - Setup dump state of adapter
4187 * @filp:               open sysfs file
4188 * @kobj:               kobject struct
4189 * @bin_attr:           bin_attribute struct
4190 * @buf:                buffer
4191 * @off:                offset
4192 * @count:              buffer size
4193 *
4194 * Return value:
4195 *      number of bytes printed to buffer
4196 **/
4197static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4198                              struct bin_attribute *bin_attr,
4199                              char *buf, loff_t off, size_t count)
4200{
4201        struct device *cdev = container_of(kobj, struct device, kobj);
4202        struct Scsi_Host *shost = class_to_shost(cdev);
4203        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4204        int rc;
4205
4206        if (!capable(CAP_SYS_ADMIN))
4207                return -EACCES;
4208
4209        if (buf[0] == '1')
4210                rc = ipr_alloc_dump(ioa_cfg);
4211        else if (buf[0] == '0')
4212                rc = ipr_free_dump(ioa_cfg);
4213        else
4214                return -EINVAL;
4215
4216        if (rc)
4217                return rc;
4218        else
4219                return count;
4220}
4221
4222static struct bin_attribute ipr_dump_attr = {
4223        .attr = {
4224                .name = "dump",
4225                .mode = S_IRUSR | S_IWUSR,
4226        },
4227        .size = 0,
4228        .read = ipr_read_dump,
4229        .write = ipr_write_dump
4230};
4231#else
4232static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4233#endif
4234
4235/**
4236 * ipr_change_queue_depth - Change the device's queue depth
4237 * @sdev:       scsi device struct
4238 * @qdepth:     depth to set
4239 * @reason:     calling context
4240 *
4241 * Return value:
4242 *      actual depth set
4243 **/
4244static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
4245                                  int reason)
4246{
4247        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4248        struct ipr_resource_entry *res;
4249        unsigned long lock_flags = 0;
4250
4251        if (reason != SCSI_QDEPTH_DEFAULT)
4252                return -EOPNOTSUPP;
4253
4254        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4255        res = (struct ipr_resource_entry *)sdev->hostdata;
4256
4257        if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4258                qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4259        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4260
4261        scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
4262        return sdev->queue_depth;
4263}
4264
4265/**
4266 * ipr_change_queue_type - Change the device's queue type
4267 * @dsev:               scsi device struct
4268 * @tag_type:   type of tags to use
4269 *
4270 * Return value:
4271 *      actual queue type set
4272 **/
4273static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
4274{
4275        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4276        struct ipr_resource_entry *res;
4277        unsigned long lock_flags = 0;
4278
4279        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4280        res = (struct ipr_resource_entry *)sdev->hostdata;
4281
4282        if (res) {
4283                if (ipr_is_gscsi(res) && sdev->tagged_supported) {
4284                        /*
4285                         * We don't bother quiescing the device here since the
4286                         * adapter firmware does it for us.
4287                         */
4288                        scsi_set_tag_type(sdev, tag_type);
4289
4290                        if (tag_type)
4291                                scsi_activate_tcq(sdev, sdev->queue_depth);
4292                        else
4293                                scsi_deactivate_tcq(sdev, sdev->queue_depth);
4294                } else
4295                        tag_type = 0;
4296        } else
4297                tag_type = 0;
4298
4299        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4300        return tag_type;
4301}
4302
4303/**
4304 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4305 * @dev:        device struct
4306 * @attr:       device attribute structure
4307 * @buf:        buffer
4308 *
4309 * Return value:
4310 *      number of bytes printed to buffer
4311 **/
4312static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4313{
4314        struct scsi_device *sdev = to_scsi_device(dev);
4315        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4316        struct ipr_resource_entry *res;
4317        unsigned long lock_flags = 0;
4318        ssize_t len = -ENXIO;
4319
4320        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4321        res = (struct ipr_resource_entry *)sdev->hostdata;
4322        if (res)
4323                len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4324        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4325        return len;
4326}
4327
4328static struct device_attribute ipr_adapter_handle_attr = {
4329        .attr = {
4330                .name =         "adapter_handle",
4331                .mode =         S_IRUSR,
4332        },
4333        .show = ipr_show_adapter_handle
4334};
4335
4336/**
4337 * ipr_show_resource_path - Show the resource path or the resource address for
4338 *                          this device.
4339 * @dev:        device struct
4340 * @attr:       device attribute structure
4341 * @buf:        buffer
4342 *
4343 * Return value:
4344 *      number of bytes printed to buffer
4345 **/
4346static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4347{
4348        struct scsi_device *sdev = to_scsi_device(dev);
4349        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4350        struct ipr_resource_entry *res;
4351        unsigned long lock_flags = 0;
4352        ssize_t len = -ENXIO;
4353        char buffer[IPR_MAX_RES_PATH_LENGTH];
4354
4355        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4356        res = (struct ipr_resource_entry *)sdev->hostdata;
4357        if (res && ioa_cfg->sis64)
4358                len = snprintf(buf, PAGE_SIZE, "%s\n",
4359                               __ipr_format_res_path(res->res_path, buffer,
4360                                                     sizeof(buffer)));
4361        else if (res)
4362                len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4363                               res->bus, res->target, res->lun);
4364
4365        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4366        return len;
4367}
4368
4369static struct device_attribute ipr_resource_path_attr = {
4370        .attr = {
4371                .name =         "resource_path",
4372                .mode =         S_IRUGO,
4373        },
4374        .show = ipr_show_resource_path
4375};
4376
4377/**
4378 * ipr_show_device_id - Show the device_id for this device.
4379 * @dev:        device struct
4380 * @attr:       device attribute structure
4381 * @buf:        buffer
4382 *
4383 * Return value:
4384 *      number of bytes printed to buffer
4385 **/
4386static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4387{
4388        struct scsi_device *sdev = to_scsi_device(dev);
4389        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4390        struct ipr_resource_entry *res;
4391        unsigned long lock_flags = 0;
4392        ssize_t len = -ENXIO;
4393
4394        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4395        res = (struct ipr_resource_entry *)sdev->hostdata;
4396        if (res && ioa_cfg->sis64)
4397                len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->dev_id);
4398        else if (res)
4399                len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4400
4401        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4402        return len;
4403}
4404
4405static struct device_attribute ipr_device_id_attr = {
4406        .attr = {
4407                .name =         "device_id",
4408                .mode =         S_IRUGO,
4409        },
4410        .show = ipr_show_device_id
4411};
4412
4413/**
4414 * ipr_show_resource_type - Show the resource type for this device.
4415 * @dev:        device struct
4416 * @attr:       device attribute structure
4417 * @buf:        buffer
4418 *
4419 * Return value:
4420 *      number of bytes printed to buffer
4421 **/
4422static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4423{
4424        struct scsi_device *sdev = to_scsi_device(dev);
4425        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4426        struct ipr_resource_entry *res;
4427        unsigned long lock_flags = 0;
4428        ssize_t len = -ENXIO;
4429
4430        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4431        res = (struct ipr_resource_entry *)sdev->hostdata;
4432
4433        if (res)
4434                len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4435
4436        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4437        return len;
4438}
4439
4440static struct device_attribute ipr_resource_type_attr = {
4441        .attr = {
4442                .name =         "resource_type",
4443                .mode =         S_IRUGO,
4444        },
4445        .show = ipr_show_resource_type
4446};
4447
4448static struct device_attribute *ipr_dev_attrs[] = {
4449        &ipr_adapter_handle_attr,
4450        &ipr_resource_path_attr,
4451        &ipr_device_id_attr,
4452        &ipr_resource_type_attr,
4453        NULL,
4454};
4455
4456/**
4457 * ipr_biosparam - Return the HSC mapping
4458 * @sdev:                       scsi device struct
4459 * @block_device:       block device pointer
4460 * @capacity:           capacity of the device
4461 * @parm:                       Array containing returned HSC values.
4462 *
4463 * This function generates the HSC parms that fdisk uses.
4464 * We want to make sure we return something that places partitions
4465 * on 4k boundaries for best performance with the IOA.
4466 *
4467 * Return value:
4468 *      0 on success
4469 **/
4470static int ipr_biosparam(struct scsi_device *sdev,
4471                         struct block_device *block_device,
4472                         sector_t capacity, int *parm)
4473{
4474        int heads, sectors;
4475        sector_t cylinders;
4476
4477        heads = 128;
4478        sectors = 32;
4479
4480        cylinders = capacity;
4481        sector_div(cylinders, (128 * 32));
4482
4483        /* return result */
4484        parm[0] = heads;
4485        parm[1] = sectors;
4486        parm[2] = cylinders;
4487
4488        return 0;
4489}
4490
4491/**
4492 * ipr_find_starget - Find target based on bus/target.
4493 * @starget:    scsi target struct
4494 *
4495 * Return value:
4496 *      resource entry pointer if found / NULL if not found
4497 **/
4498static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4499{
4500        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4501        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4502        struct ipr_resource_entry *res;
4503
4504        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4505                if ((res->bus == starget->channel) &&
4506                    (res->target == starget->id)) {
4507                        return res;
4508                }
4509        }
4510
4511        return NULL;
4512}
4513
4514static struct ata_port_info sata_port_info;
4515
4516/**
4517 * ipr_target_alloc - Prepare for commands to a SCSI target
4518 * @starget:    scsi target struct
4519 *
4520 * If the device is a SATA device, this function allocates an
4521 * ATA port with libata, else it does nothing.
4522 *
4523 * Return value:
4524 *      0 on success / non-0 on failure
4525 **/
4526static int ipr_target_alloc(struct scsi_target *starget)
4527{
4528        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4529        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4530        struct ipr_sata_port *sata_port;
4531        struct ata_port *ap;
4532        struct ipr_resource_entry *res;
4533        unsigned long lock_flags;
4534
4535        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4536        res = ipr_find_starget(starget);
4537        starget->hostdata = NULL;
4538
4539        if (res && ipr_is_gata(res)) {
4540                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4541                sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4542                if (!sata_port)
4543                        return -ENOMEM;
4544
4545                ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4546                if (ap) {
4547                        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4548                        sata_port->ioa_cfg = ioa_cfg;
4549                        sata_port->ap = ap;
4550                        sata_port->res = res;
4551
4552                        res->sata_port = sata_port;
4553                        ap->private_data = sata_port;
4554                        starget->hostdata = sata_port;
4555                } else {
4556                        kfree(sata_port);
4557                        return -ENOMEM;
4558                }
4559        }
4560        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4561
4562        return 0;
4563}
4564
4565/**
4566 * ipr_target_destroy - Destroy a SCSI target
4567 * @starget:    scsi target struct
4568 *
4569 * If the device was a SATA device, this function frees the libata
4570 * ATA port, else it does nothing.
4571 *
4572 **/
4573static void ipr_target_destroy(struct scsi_target *starget)
4574{
4575        struct ipr_sata_port *sata_port = starget->hostdata;
4576        struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4577        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4578
4579        if (ioa_cfg->sis64) {
4580                if (!ipr_find_starget(starget)) {
4581                        if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4582                                clear_bit(starget->id, ioa_cfg->array_ids);
4583                        else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4584                                clear_bit(starget->id, ioa_cfg->vset_ids);
4585                        else if (starget->channel == 0)
4586                                clear_bit(starget->id, ioa_cfg->target_ids);
4587                }
4588        }
4589
4590        if (sata_port) {
4591                starget->hostdata = NULL;
4592                ata_sas_port_destroy(sata_port->ap);
4593                kfree(sata_port);
4594        }
4595}
4596
4597/**
4598 * ipr_find_sdev - Find device based on bus/target/lun.
4599 * @sdev:       scsi device struct
4600 *
4601 * Return value:
4602 *      resource entry pointer if found / NULL if not found
4603 **/
4604static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4605{
4606        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4607        struct ipr_resource_entry *res;
4608
4609        list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4610                if ((res->bus == sdev->channel) &&
4611                    (res->target == sdev->id) &&
4612                    (res->lun == sdev->lun))
4613                        return res;
4614        }
4615
4616        return NULL;
4617}
4618
4619/**
4620 * ipr_slave_destroy - Unconfigure a SCSI device
4621 * @sdev:       scsi device struct
4622 *
4623 * Return value:
4624 *      nothing
4625 **/
4626static void ipr_slave_destroy(struct scsi_device *sdev)
4627{
4628        struct ipr_resource_entry *res;
4629        struct ipr_ioa_cfg *ioa_cfg;
4630        unsigned long lock_flags = 0;
4631
4632        ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4633
4634        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4635        res = (struct ipr_resource_entry *) sdev->hostdata;
4636        if (res) {
4637                if (res->sata_port)
4638                        res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4639                sdev->hostdata = NULL;
4640                res->sdev = NULL;
4641                res->sata_port = NULL;
4642        }
4643        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4644}
4645
4646/**
4647 * ipr_slave_configure - Configure a SCSI device
4648 * @sdev:       scsi device struct
4649 *
4650 * This function configures the specified scsi device.
4651 *
4652 * Return value:
4653 *      0 on success
4654 **/
4655static int ipr_slave_configure(struct scsi_device *sdev)
4656{
4657        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4658        struct ipr_resource_entry *res;
4659        struct ata_port *ap = NULL;
4660        unsigned long lock_flags = 0;
4661        char buffer[IPR_MAX_RES_PATH_LENGTH];
4662
4663        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4664        res = sdev->hostdata;
4665        if (res) {
4666                if (ipr_is_af_dasd_device(res))
4667                        sdev->type = TYPE_RAID;
4668                if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4669                        sdev->scsi_level = 4;
4670                        sdev->no_uld_attach = 1;
4671                }
4672                if (ipr_is_vset_device(res)) {
4673                        blk_queue_rq_timeout(sdev->request_queue,
4674                                             IPR_VSET_RW_TIMEOUT);
4675                        blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4676                }
4677                if (ipr_is_gata(res) && res->sata_port)
4678                        ap = res->sata_port->ap;
4679                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4680
4681                if (ap) {
4682                        scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
4683                        ata_sas_slave_configure(sdev, ap);
4684                } else
4685                        scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
4686                if (ioa_cfg->sis64)
4687                        sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4688                                    ipr_format_res_path(ioa_cfg,
4689                                res->res_path, buffer, sizeof(buffer)));
4690                return 0;
4691        }
4692        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4693        return 0;
4694}
4695
4696/**
4697 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4698 * @sdev:       scsi device struct
4699 *
4700 * This function initializes an ATA port so that future commands
4701 * sent through queuecommand will work.
4702 *
4703 * Return value:
4704 *      0 on success
4705 **/
4706static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4707{
4708        struct ipr_sata_port *sata_port = NULL;
4709        int rc = -ENXIO;
4710
4711        ENTER;
4712        if (sdev->sdev_target)
4713                sata_port = sdev->sdev_target->hostdata;
4714        if (sata_port) {
4715                rc = ata_sas_port_init(sata_port->ap);
4716                if (rc == 0)
4717                        rc = ata_sas_sync_probe(sata_port->ap);
4718        }
4719
4720        if (rc)
4721                ipr_slave_destroy(sdev);
4722
4723        LEAVE;
4724        return rc;
4725}
4726
4727/**
4728 * ipr_slave_alloc - Prepare for commands to a device.
4729 * @sdev:       scsi device struct
4730 *
4731 * This function saves a pointer to the resource entry
4732 * in the scsi device struct if the device exists. We
4733 * can then use this pointer in ipr_queuecommand when
4734 * handling new commands.
4735 *
4736 * Return value:
4737 *      0 on success / -ENXIO if device does not exist
4738 **/
4739static int ipr_slave_alloc(struct scsi_device *sdev)
4740{
4741        struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4742        struct ipr_resource_entry *res;
4743        unsigned long lock_flags;
4744        int rc = -ENXIO;
4745
4746        sdev->hostdata = NULL;
4747
4748        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4749
4750        res = ipr_find_sdev(sdev);
4751        if (res) {
4752                res->sdev = sdev;
4753                res->add_to_ml = 0;
4754                res->in_erp = 0;
4755                sdev->hostdata = res;
4756                if (!ipr_is_naca_model(res))
4757                        res->needs_sync_complete = 1;
4758                rc = 0;
4759                if (ipr_is_gata(res)) {
4760                        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4761                        return ipr_ata_slave_alloc(sdev);
4762                }
4763        }
4764
4765        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4766
4767        return rc;
4768}
4769
4770static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
4771{
4772        struct ipr_ioa_cfg *ioa_cfg;
4773        unsigned long lock_flags = 0;
4774        int rc = SUCCESS;
4775
4776        ENTER;
4777        ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
4778        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4779
4780        if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
4781                ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
4782                dev_err(&ioa_cfg->pdev->dev,
4783                        "Adapter being reset as a result of error recovery.\n");
4784
4785                if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
4786                        ioa_cfg->sdt_state = GET_DUMP;
4787        }
4788
4789        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4790        wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4791        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4792
4793        /* If we got hit with a host reset while we were already resetting
4794         the adapter for some reason, and the reset failed. */
4795        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
4796                ipr_trace;
4797                rc = FAILED;
4798        }
4799
4800        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4801        LEAVE;
4802        return rc;
4803}
4804
4805/**
4806 * ipr_device_reset - Reset the device
4807 * @ioa_cfg:    ioa config struct
4808 * @res:                resource entry struct
4809 *
4810 * This function issues a device reset to the affected device.
4811 * If the device is a SCSI device, a LUN reset will be sent
4812 * to the device first. If that does not work, a target reset
4813 * will be sent. If the device is a SATA device, a PHY reset will
4814 * be sent.
4815 *
4816 * Return value:
4817 *      0 on success / non-zero on failure
4818 **/
4819static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
4820                            struct ipr_resource_entry *res)
4821{
4822        struct ipr_cmnd *ipr_cmd;
4823        struct ipr_ioarcb *ioarcb;
4824        struct ipr_cmd_pkt *cmd_pkt;
4825        struct ipr_ioarcb_ata_regs *regs;
4826        u32 ioasc;
4827
4828        ENTER;
4829        ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4830        ioarcb = &ipr_cmd->ioarcb;
4831        cmd_pkt = &ioarcb->cmd_pkt;
4832
4833        if (ipr_cmd->ioa_cfg->sis64) {
4834                regs = &ipr_cmd->i.ata_ioadl.regs;
4835                ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
4836        } else
4837                regs = &ioarcb->u.add_data.u.regs;
4838
4839        ioarcb->res_handle = res->res_handle;
4840        cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4841        cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
4842        if (ipr_is_gata(res)) {
4843                cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
4844                ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
4845                regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
4846        }
4847
4848        ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
4849        ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
4850        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
4851        if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
4852                if (ipr_cmd->ioa_cfg->sis64)
4853                        memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
4854                               sizeof(struct ipr_ioasa_gata));
4855                else
4856                        memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
4857                               sizeof(struct ipr_ioasa_gata));
4858        }
4859
4860        LEAVE;
4861        return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
4862}
4863
4864/**
4865 * ipr_sata_reset - Reset the SATA port
4866 * @link:       SATA link to reset
4867 * @classes:    class of the attached device
4868 *
4869 * This function issues a SATA phy reset to the affected ATA link.
4870 *
4871 * Return value:
4872 *      0 on success / non-zero on failure
4873 **/
4874static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
4875                                unsigned long deadline)
4876{
4877        struct ipr_sata_port *sata_port = link->ap->private_data;
4878        struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
4879        struct ipr_resource_entry *res;
4880        unsigned long lock_flags = 0;
4881        int rc = -ENXIO;
4882
4883        ENTER;
4884        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4885        while (ioa_cfg->in_reset_reload) {
4886                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4887                wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4888                spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4889        }
4890
4891        res = sata_port->res;
4892        if (res) {
4893                rc = ipr_device_reset(ioa_cfg, res);
4894                *classes = res->ata_class;
4895        }
4896
4897        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4898        LEAVE;
4899        return rc;
4900}
4901
4902/**
4903 * ipr_eh_dev_reset - Reset the device
4904 * @scsi_cmd:   scsi command struct
4905 *
4906 * This function issues a device reset to the affected device.
4907 * A LUN reset will be sent to the device first. If that does
4908 * not work, a target reset will be sent.
4909 *
4910 * Return value:
4911 *      SUCCESS / FAILED
4912 **/
4913static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
4914{
4915        struct ipr_cmnd *ipr_cmd;
4916        struct ipr_ioa_cfg *ioa_cfg;
4917        struct ipr_resource_entry *res;
4918        struct ata_port *ap;
4919        int rc = 0;
4920        struct ipr_hrr_queue *hrrq;
4921
4922        ENTER;
4923        ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
4924        res = scsi_cmd->device->hostdata;
4925
4926        if (!res)
4927                return FAILED;
4928
4929        /*
4930         * If we are currently going through reset/reload, return failed. This will force the
4931         * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
4932         * reset to complete
4933         */
4934        if (ioa_cfg->in_reset_reload)
4935                return FAILED;
4936        if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
4937                return FAILED;
4938
4939        for_each_hrrq(hrrq, ioa_cfg) {
4940                spin_lock(&hrrq->_lock);
4941                list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
4942                        if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
4943                                if (ipr_cmd->scsi_cmd)
4944                                        ipr_cmd->done = ipr_scsi_eh_done;
4945                                if (ipr_cmd->qc)
4946                                        ipr_cmd->done = ipr_sata_eh_done;
4947                                if (ipr_cmd->qc &&
4948                                    !(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
4949                                        ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
4950                                        ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
4951                                }
4952                        }
4953                }
4954                spin_unlock(&hrrq->_lock);
4955        }
4956        res->resetting_device = 1;
4957        scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
4958
4959        if (ipr_is_gata(res) && res->sata_port) {
4960                ap = res->sata_port->ap;
4961                spin_unlock_irq(scsi_cmd->device->host->host_lock);
4962                ata_std_error_handler(ap);
4963                spin_lock_irq(scsi_cmd->device->host->host_lock);
4964
4965                for_each_hrrq(hrrq, ioa_cfg) {
4966                        spin_lock(&hrrq->_lock);
4967                        list_for_each_entry(ipr_cmd,
4968                                            &hrrq->hrrq_pending_q, queue) {
4969                                if (ipr_cmd->ioarcb.res_handle ==
4970                                    res->res_handle) {
4971                                        rc = -EIO;
4972                                        break;
4973                                }
4974                        }
4975                        spin_unlock(&hrrq->_lock);
4976                }
4977        } else
4978                rc = ipr_device_reset(ioa_cfg, res);
4979        res->resetting_device = 0;
4980
4981        LEAVE;
4982        return rc ? FAILED : SUCCESS;
4983}
4984
4985static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
4986{
4987        int rc;
4988
4989        spin_lock_irq(cmd->device->host->host_lock);
4990        rc = __ipr_eh_dev_reset(cmd);
4991        spin_unlock_irq(cmd->device->host->host_lock);
4992
4993        return rc;
4994}
4995
4996/**
4997 * ipr_bus_reset_done - Op done function for bus reset.
4998 * @ipr_cmd:    ipr command struct
4999 *
5000 * This function is the op done function for a bus reset
5001 *
5002 * Return value:
5003 *      none
5004 **/
5005static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
5006{
5007        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5008        struct ipr_resource_entry *res;
5009
5010        ENTER;
5011        if (!ioa_cfg->sis64)
5012                list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
5013                        if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
5014                                scsi_report_bus_reset(ioa_cfg->host, res->bus);
5015                                break;
5016                        }
5017                }
5018
5019        /*
5020         * If abort has not completed, indicate the reset has, else call the
5021         * abort's done function to wake the sleeping eh thread
5022         */
5023        if (ipr_cmd->sibling->sibling)
5024                ipr_cmd->sibling->sibling = NULL;
5025        else
5026                ipr_cmd->sibling->done(ipr_cmd->sibling);
5027
5028        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5029        LEAVE;
5030}
5031
5032/**
5033 * ipr_abort_timeout - An abort task has timed out
5034 * @ipr_cmd:    ipr command struct
5035 *
5036 * This function handles when an abort task times out. If this
5037 * happens we issue a bus reset since we have resources tied
5038 * up that must be freed before returning to the midlayer.
5039 *
5040 * Return value:
5041 *      none
5042 **/
5043static void ipr_abort_timeout(struct ipr_cmnd *ipr_cmd)
5044{
5045        struct ipr_cmnd *reset_cmd;
5046        struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5047        struct ipr_cmd_pkt *cmd_pkt;
5048        unsigned long lock_flags = 0;
5049
5050        ENTER;
5051        spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
5052        if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
5053                spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5054                return;
5055        }
5056
5057        sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
5058        reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5059        ipr_cmd->sibling = reset_cmd;
5060        reset_cmd->sibling = ipr_cmd;
5061        reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
5062        cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
5063        cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5064        cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
5065        cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
5066
5067        ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
5068        spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
5069        LEAVE;
5070}
5071
5072/**
5073 * ipr_cancel_op - Cancel specified op
5074 * @scsi_cmd:   scsi command struct
5075 *
5076 * This function cancels specified op.
5077 *
5078 * Return value:
5079 *      SUCCESS / FAILED
5080 **/
5081static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
5082{
5083        struct ipr_cmnd *ipr_cmd;
5084        struct ipr_ioa_cfg *ioa_cfg;
5085        struct ipr_resource_entry *res;
5086        struct ipr_cmd_pkt *cmd_pkt;
5087        u32 ioasc, int_reg;
5088        int op_found = 0;
5089        struct ipr_hrr_queue *hrrq;
5090
5091        ENTER;
5092        ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
5093        res = scsi_cmd->device->hostdata;
5094
5095        /* If we are currently going through reset/reload, return failed.
5096         * This will force the mid-layer to call ipr_eh_host_reset,
5097         * which will then go to sleep and wait for the reset to complete
5098         */
5099        if (ioa_cfg->in_reset_reload ||
5100            ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
5101                return FAILED;
5102        if (!res)
5103                return FAILED;
5104
5105        /*
5106         * If we are aborting a timed out op, chances are that the timeout was caused
5107         * by a still not detected EEH error. In such cases, reading a register will
5108         * trigger the EEH recovery infrastructure.
5109         */
5110        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5111
5112        if (!ipr_is_gscsi(res))
5113                return FAILED;
5114
5115        for_each_hrrq(hrrq, ioa_cfg) {
5116                spin_lock(&hrrq->_lock);
5117                list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
5118                        if (ipr_cmd->scsi_cmd == scsi_cmd) {
5119                                ipr_cmd->done = ipr_scsi_eh_done;
5120                                op_found = 1;
5121                                break;
5122                        }
5123                }
5124                spin_unlock(&hrrq->_lock);
5125        }
5126
5127        if (!op_found)
5128                return SUCCESS;
5129
5130        ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5131        ipr_cmd->ioarcb.res_handle = res->res_handle;
5132        cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
5133        cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
5134        cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
5135        ipr_cmd->u.sdev = scsi_cmd->device;
5136
5137        scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
5138                    scsi_cmd->cmnd[0]);
5139        ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
5140        ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
5141
5142        /*
5143         * If the abort task timed out and we sent a bus reset, we will get
5144         * one the following responses to the abort
5145         */
5146        if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
5147                ioasc = 0;
5148                ipr_trace;
5149        }
5150
5151        list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
5152        if (!ipr_is_naca_model(res))
5153                res->needs_sync_complete = 1;
5154
5155        LEAVE;
5156        return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
5157}
5158
5159/**
5160 * ipr_eh_abort - Abort a single op
5161 * @scsi_cmd:   scsi command struct
5162 *
5163 * Return value:
5164 *      SUCCESS / FAILED
5165 **/
5166static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
5167{
5168        unsigned long flags;
5169        int rc;
5170
5171        ENTER;
5172
5173        spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
5174        rc = ipr_cancel_op(scsi_cmd);
5175        spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
5176
5177        LEAVE;
5178        return rc;
5179}
5180
5181/**
5182 * ipr_handle_other_interrupt - Handle "other" interrupts
5183 * @ioa_cfg:    ioa config struct
5184 * @int_reg:    interrupt register
5185 *
5186 * Return value:
5187 *      IRQ_NONE / IRQ_HANDLED
5188 **/
5189static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
5190                                              u32 int_reg)
5191{
5192        irqreturn_t rc = IRQ_HANDLED;
5193        u32 int_mask_reg;
5194
5195        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
5196        int_reg &= ~int_mask_reg;
5197
5198        /* If an interrupt on the adapter did not occur, ignore it.
5199         * Or in the case of SIS 64, check for a stage change interrupt.
5200         */
5201        if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
5202                if (ioa_cfg->sis64) {
5203                        int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
5204                        int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5205                        if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
5206
5207                                /* clear stage change */
5208                                writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
5209                                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
5210                                list_del(&ioa_cfg->reset_cmd->queue);
5211                                del_timer(&ioa_cfg->reset_cmd->timer);
5212                                ipr_reset_ioa_job(ioa_cfg->reset_cmd);
5213                                return IRQ_HANDLED;
5214                        }
5215                }
5216
5217                return IRQ_NONE;
5218        }
5219
5220        if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
5221                /* Mask the interrupt */
5222                writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
5223
5224                /* Clear the interrupt */
5225                writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.clr_interrupt_reg);
5226                int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
5227
5228                list_del(&ioa_cfg->reset_cmd->queue);
5229                del_timer(&ioa_cfg->reset_cmd->timer);
5230                ipr_reset_ioa_job(ioa_cfg->