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