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