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