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