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