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