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 * 674 * Return value: 675 * none 676 **/ 677 static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd, 678 void (*fast_done) (struct ipr_cmnd *)) 679 { 680 ipr_reinit_ipr_cmnd(ipr_cmd); 681 ipr_cmd->u.scratch = 0; 682 ipr_cmd->sibling = NULL; 683 ipr_cmd->eh_comp = NULL; 684 ipr_cmd->fast_done = fast_done; 685 timer_setup(&ipr_cmd->timer, NULL, 0); 686 } 687 688 /** 689 * __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block 690 * @ioa_cfg: ioa config struct 691 * 692 * Return value: 693 * pointer to ipr command struct 694 **/ 695 static 696 struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq) 697 { 698 struct ipr_cmnd *ipr_cmd = NULL; 699 700 if (likely(!list_empty(&hrrq->hrrq_free_q))) { 701 ipr_cmd = list_entry(hrrq->hrrq_free_q.next, 702 struct ipr_cmnd, queue); 703 list_del(&ipr_cmd->queue); 704 } 705 706 707 return ipr_cmd; 708 } 709 710 /** 711 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it 712 * @ioa_cfg: ioa config struct 713 * 714 * Return value: 715 * pointer to ipr command struct 716 **/ 717 static 718 struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg) 719 { 720 struct ipr_cmnd *ipr_cmd = 721 __ipr_get_free_ipr_cmnd(&ioa_cfg->hrrq[IPR_INIT_HRRQ]); 722 ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done); 723 return ipr_cmd; 724 } 725 726 /** 727 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts 728 * @ioa_cfg: ioa config struct 729 * @clr_ints: interrupts to clear 730 * 731 * This function masks all interrupts on the adapter, then clears the 732 * interrupts specified in the mask 733 * 734 * Return value: 735 * none 736 **/ 737 static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg, 738 u32 clr_ints) 739 { 740 volatile u32 int_reg; 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 int_reg = 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_cmd->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 * @buf: 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 += snprintf(p, buffer + len - p, "%02X", res_path[0]); 1303 for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++) 1304 p += snprintf(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 * @buf: 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 += snprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no); 1326 __ipr_format_res_path(res_path, p, len - (buffer - p)); 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 * @cfgtew: config table entry wrapper struct 1395 * 1396 * Return value: 1397 * none 1398 **/ 1399 static void ipr_clear_res_target(struct ipr_resource_entry *res) 1400 { 1401 struct ipr_resource_entry *gscsi_res = NULL; 1402 struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg; 1403 1404 if (!ioa_cfg->sis64) 1405 return; 1406 1407 if (res->bus == IPR_ARRAY_VIRTUAL_BUS) 1408 clear_bit(res->target, ioa_cfg->array_ids); 1409 else if (res->bus == IPR_VSET_VIRTUAL_BUS) 1410 clear_bit(res->target, ioa_cfg->vset_ids); 1411 else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) { 1412 list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) 1413 if (gscsi_res->dev_id == res->dev_id && gscsi_res != res) 1414 return; 1415 clear_bit(res->target, ioa_cfg->target_ids); 1416 1417 } else if (res->bus == 0) 1418 clear_bit(res->target, ioa_cfg->target_ids); 1419 } 1420 1421 /** 1422 * ipr_handle_config_change - Handle a config change from the adapter 1423 * @ioa_cfg: ioa config struct 1424 * @hostrcb: hostrcb 1425 * 1426 * Return value: 1427 * none 1428 **/ 1429 static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg, 1430 struct ipr_hostrcb *hostrcb) 1431 { 1432 struct ipr_resource_entry *res = NULL; 1433 struct ipr_config_table_entry_wrapper cfgtew; 1434 __be32 cc_res_handle; 1435 1436 u32 is_ndn = 1; 1437 1438 if (ioa_cfg->sis64) { 1439 cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64; 1440 cc_res_handle = cfgtew.u.cfgte64->res_handle; 1441 } else { 1442 cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte; 1443 cc_res_handle = cfgtew.u.cfgte->res_handle; 1444 } 1445 1446 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) { 1447 if (res->res_handle == cc_res_handle) { 1448 is_ndn = 0; 1449 break; 1450 } 1451 } 1452 1453 if (is_ndn) { 1454 if (list_empty(&ioa_cfg->free_res_q)) { 1455 ipr_send_hcam(ioa_cfg, 1456 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, 1457 hostrcb); 1458 return; 1459 } 1460 1461 res = list_entry(ioa_cfg->free_res_q.next, 1462 struct ipr_resource_entry, queue); 1463 1464 list_del(&res->queue); 1465 ipr_init_res_entry(res, &cfgtew); 1466 list_add_tail(&res->queue, &ioa_cfg->used_res_q); 1467 } 1468 1469 ipr_update_res_entry(res, &cfgtew); 1470 1471 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) { 1472 if (res->sdev) { 1473 res->del_from_ml = 1; 1474 res->res_handle = IPR_INVALID_RES_HANDLE; 1475 schedule_work(&ioa_cfg->work_q); 1476 } else { 1477 ipr_clear_res_target(res); 1478 list_move_tail(&res->queue, &ioa_cfg->free_res_q); 1479 } 1480 } else if (!res->sdev || res->del_from_ml) { 1481 res->add_to_ml = 1; 1482 schedule_work(&ioa_cfg->work_q); 1483 } 1484 1485 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb); 1486 } 1487 1488 /** 1489 * ipr_process_ccn - Op done function for a CCN. 1490 * @ipr_cmd: ipr command struct 1491 * 1492 * This function is the op done function for a configuration 1493 * change notification host controlled async from the adapter. 1494 * 1495 * Return value: 1496 * none 1497 **/ 1498 static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd) 1499 { 1500 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 1501 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb; 1502 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 1503 1504 list_del_init(&hostrcb->queue); 1505 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 1506 1507 if (ioasc) { 1508 if (ioasc != IPR_IOASC_IOA_WAS_RESET && 1509 ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) 1510 dev_err(&ioa_cfg->pdev->dev, 1511 "Host RCB failed with IOASC: 0x%08X\n", ioasc); 1512 1513 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb); 1514 } else { 1515 ipr_handle_config_change(ioa_cfg, hostrcb); 1516 } 1517 } 1518 1519 /** 1520 * strip_and_pad_whitespace - Strip and pad trailing whitespace. 1521 * @i: index into buffer 1522 * @buf: string to modify 1523 * 1524 * This function will strip all trailing whitespace, pad the end 1525 * of the string with a single space, and NULL terminate the string. 1526 * 1527 * Return value: 1528 * new length of string 1529 **/ 1530 static int strip_and_pad_whitespace(int i, char *buf) 1531 { 1532 while (i && buf[i] == ' ') 1533 i--; 1534 buf[i+1] = ' '; 1535 buf[i+2] = '\0'; 1536 return i + 2; 1537 } 1538 1539 /** 1540 * ipr_log_vpd_compact - Log the passed extended VPD compactly. 1541 * @prefix: string to print at start of printk 1542 * @hostrcb: hostrcb pointer 1543 * @vpd: vendor/product id/sn struct 1544 * 1545 * Return value: 1546 * none 1547 **/ 1548 static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb, 1549 struct ipr_vpd *vpd) 1550 { 1551 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3]; 1552 int i = 0; 1553 1554 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN); 1555 i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer); 1556 1557 memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN); 1558 i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer); 1559 1560 memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN); 1561 buffer[IPR_SERIAL_NUM_LEN + i] = '\0'; 1562 1563 ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer); 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 * @ipr_cmd: 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 * @ipr_cmd: 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 = container_of(kobj, struct device, 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 * @buf: buffer 3488 * 3489 * Return value: 3490 * number of bytes printed to buffer 3491 **/ 3492 static ssize_t ipr_show_fw_version(struct device *dev, 3493 struct device_attribute *attr, char *buf) 3494 { 3495 struct Scsi_Host *shost = class_to_shost(dev); 3496 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3497 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data; 3498 unsigned long lock_flags = 0; 3499 int len; 3500 3501 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3502 len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n", 3503 ucode_vpd->major_release, ucode_vpd->card_type, 3504 ucode_vpd->minor_release[0], 3505 ucode_vpd->minor_release[1]); 3506 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3507 return len; 3508 } 3509 3510 static struct device_attribute ipr_fw_version_attr = { 3511 .attr = { 3512 .name = "fw_version", 3513 .mode = S_IRUGO, 3514 }, 3515 .show = ipr_show_fw_version, 3516 }; 3517 3518 /** 3519 * ipr_show_log_level - Show the adapter's error logging level 3520 * @dev: class device struct 3521 * @buf: buffer 3522 * 3523 * Return value: 3524 * number of bytes printed to buffer 3525 **/ 3526 static ssize_t ipr_show_log_level(struct device *dev, 3527 struct device_attribute *attr, char *buf) 3528 { 3529 struct Scsi_Host *shost = class_to_shost(dev); 3530 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3531 unsigned long lock_flags = 0; 3532 int len; 3533 3534 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3535 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level); 3536 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3537 return len; 3538 } 3539 3540 /** 3541 * ipr_store_log_level - Change the adapter's error logging level 3542 * @dev: class device struct 3543 * @buf: buffer 3544 * 3545 * Return value: 3546 * number of bytes printed to buffer 3547 **/ 3548 static ssize_t ipr_store_log_level(struct device *dev, 3549 struct device_attribute *attr, 3550 const char *buf, size_t count) 3551 { 3552 struct Scsi_Host *shost = class_to_shost(dev); 3553 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3554 unsigned long lock_flags = 0; 3555 3556 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3557 ioa_cfg->log_level = simple_strtoul(buf, NULL, 10); 3558 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3559 return strlen(buf); 3560 } 3561 3562 static struct device_attribute ipr_log_level_attr = { 3563 .attr = { 3564 .name = "log_level", 3565 .mode = S_IRUGO | S_IWUSR, 3566 }, 3567 .show = ipr_show_log_level, 3568 .store = ipr_store_log_level 3569 }; 3570 3571 /** 3572 * ipr_store_diagnostics - IOA Diagnostics interface 3573 * @dev: device struct 3574 * @buf: buffer 3575 * @count: buffer size 3576 * 3577 * This function will reset the adapter and wait a reasonable 3578 * amount of time for any errors that the adapter might log. 3579 * 3580 * Return value: 3581 * count on success / other on failure 3582 **/ 3583 static ssize_t ipr_store_diagnostics(struct device *dev, 3584 struct device_attribute *attr, 3585 const char *buf, size_t count) 3586 { 3587 struct Scsi_Host *shost = class_to_shost(dev); 3588 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3589 unsigned long lock_flags = 0; 3590 int rc = count; 3591 3592 if (!capable(CAP_SYS_ADMIN)) 3593 return -EACCES; 3594 3595 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3596 while (ioa_cfg->in_reset_reload) { 3597 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3598 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 3599 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3600 } 3601 3602 ioa_cfg->errors_logged = 0; 3603 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL); 3604 3605 if (ioa_cfg->in_reset_reload) { 3606 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3607 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 3608 3609 /* Wait for a second for any errors to be logged */ 3610 msleep(1000); 3611 } else { 3612 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3613 return -EIO; 3614 } 3615 3616 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3617 if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged) 3618 rc = -EIO; 3619 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3620 3621 return rc; 3622 } 3623 3624 static struct device_attribute ipr_diagnostics_attr = { 3625 .attr = { 3626 .name = "run_diagnostics", 3627 .mode = S_IWUSR, 3628 }, 3629 .store = ipr_store_diagnostics 3630 }; 3631 3632 /** 3633 * ipr_show_adapter_state - Show the adapter's state 3634 * @class_dev: device struct 3635 * @buf: buffer 3636 * 3637 * Return value: 3638 * number of bytes printed to buffer 3639 **/ 3640 static ssize_t ipr_show_adapter_state(struct device *dev, 3641 struct device_attribute *attr, char *buf) 3642 { 3643 struct Scsi_Host *shost = class_to_shost(dev); 3644 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3645 unsigned long lock_flags = 0; 3646 int len; 3647 3648 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3649 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) 3650 len = snprintf(buf, PAGE_SIZE, "offline\n"); 3651 else 3652 len = snprintf(buf, PAGE_SIZE, "online\n"); 3653 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3654 return len; 3655 } 3656 3657 /** 3658 * ipr_store_adapter_state - Change adapter state 3659 * @dev: device struct 3660 * @buf: buffer 3661 * @count: buffer size 3662 * 3663 * This function will change the adapter's state. 3664 * 3665 * Return value: 3666 * count on success / other on failure 3667 **/ 3668 static ssize_t ipr_store_adapter_state(struct device *dev, 3669 struct device_attribute *attr, 3670 const char *buf, size_t count) 3671 { 3672 struct Scsi_Host *shost = class_to_shost(dev); 3673 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3674 unsigned long lock_flags; 3675 int result = count, i; 3676 3677 if (!capable(CAP_SYS_ADMIN)) 3678 return -EACCES; 3679 3680 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3681 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && 3682 !strncmp(buf, "online", 6)) { 3683 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 3684 spin_lock(&ioa_cfg->hrrq[i]._lock); 3685 ioa_cfg->hrrq[i].ioa_is_dead = 0; 3686 spin_unlock(&ioa_cfg->hrrq[i]._lock); 3687 } 3688 wmb(); 3689 ioa_cfg->reset_retries = 0; 3690 ioa_cfg->in_ioa_bringdown = 0; 3691 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 3692 } 3693 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3694 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 3695 3696 return result; 3697 } 3698 3699 static struct device_attribute ipr_ioa_state_attr = { 3700 .attr = { 3701 .name = "online_state", 3702 .mode = S_IRUGO | S_IWUSR, 3703 }, 3704 .show = ipr_show_adapter_state, 3705 .store = ipr_store_adapter_state 3706 }; 3707 3708 /** 3709 * ipr_store_reset_adapter - Reset the adapter 3710 * @dev: device struct 3711 * @buf: buffer 3712 * @count: buffer size 3713 * 3714 * This function will reset the adapter. 3715 * 3716 * Return value: 3717 * count on success / other on failure 3718 **/ 3719 static ssize_t ipr_store_reset_adapter(struct device *dev, 3720 struct device_attribute *attr, 3721 const char *buf, size_t count) 3722 { 3723 struct Scsi_Host *shost = class_to_shost(dev); 3724 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3725 unsigned long lock_flags; 3726 int result = count; 3727 3728 if (!capable(CAP_SYS_ADMIN)) 3729 return -EACCES; 3730 3731 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 3732 if (!ioa_cfg->in_reset_reload) 3733 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL); 3734 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 3735 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 3736 3737 return result; 3738 } 3739 3740 static struct device_attribute ipr_ioa_reset_attr = { 3741 .attr = { 3742 .name = "reset_host", 3743 .mode = S_IWUSR, 3744 }, 3745 .store = ipr_store_reset_adapter 3746 }; 3747 3748 static int ipr_iopoll(struct irq_poll *iop, int budget); 3749 /** 3750 * ipr_show_iopoll_weight - Show ipr polling mode 3751 * @dev: class device struct 3752 * @buf: buffer 3753 * 3754 * Return value: 3755 * number of bytes printed to buffer 3756 **/ 3757 static ssize_t ipr_show_iopoll_weight(struct device *dev, 3758 struct device_attribute *attr, char *buf) 3759 { 3760 struct Scsi_Host *shost = class_to_shost(dev); 3761 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3762 unsigned long lock_flags = 0; 3763 int len; 3764 3765 spin_lock_irqsave(shost->host_lock, lock_flags); 3766 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight); 3767 spin_unlock_irqrestore(shost->host_lock, lock_flags); 3768 3769 return len; 3770 } 3771 3772 /** 3773 * ipr_store_iopoll_weight - Change the adapter's polling mode 3774 * @dev: class device struct 3775 * @buf: buffer 3776 * 3777 * Return value: 3778 * number of bytes printed to buffer 3779 **/ 3780 static ssize_t ipr_store_iopoll_weight(struct device *dev, 3781 struct device_attribute *attr, 3782 const char *buf, size_t count) 3783 { 3784 struct Scsi_Host *shost = class_to_shost(dev); 3785 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 3786 unsigned long user_iopoll_weight; 3787 unsigned long lock_flags = 0; 3788 int i; 3789 3790 if (!ioa_cfg->sis64) { 3791 dev_info(&ioa_cfg->pdev->dev, "irq_poll not supported on this adapter\n"); 3792 return -EINVAL; 3793 } 3794 if (kstrtoul(buf, 10, &user_iopoll_weight)) 3795 return -EINVAL; 3796 3797 if (user_iopoll_weight > 256) { 3798 dev_info(&ioa_cfg->pdev->dev, "Invalid irq_poll weight. It must be less than 256\n"); 3799 return -EINVAL; 3800 } 3801 3802 if (user_iopoll_weight == ioa_cfg->iopoll_weight) { 3803 dev_info(&ioa_cfg->pdev->dev, "Current irq_poll weight has the same weight\n"); 3804 return strlen(buf); 3805 } 3806 3807 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) { 3808 for (i = 1; i < ioa_cfg->hrrq_num; i++) 3809 irq_poll_disable(&ioa_cfg->hrrq[i].iopoll); 3810 } 3811 3812 spin_lock_irqsave(shost->host_lock, lock_flags); 3813 ioa_cfg->iopoll_weight = user_iopoll_weight; 3814 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) { 3815 for (i = 1; i < ioa_cfg->hrrq_num; i++) { 3816 irq_poll_init(&ioa_cfg->hrrq[i].iopoll, 3817 ioa_cfg->iopoll_weight, ipr_iopoll); 3818 } 3819 } 3820 spin_unlock_irqrestore(shost->host_lock, lock_flags); 3821 3822 return strlen(buf); 3823 } 3824 3825 static struct device_attribute ipr_iopoll_weight_attr = { 3826 .attr = { 3827 .name = "iopoll_weight", 3828 .mode = S_IRUGO | S_IWUSR, 3829 }, 3830 .show = ipr_show_iopoll_weight, 3831 .store = ipr_store_iopoll_weight 3832 }; 3833 3834 /** 3835 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer 3836 * @buf_len: buffer length 3837 * 3838 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather 3839 * list to use for microcode download 3840 * 3841 * Return value: 3842 * pointer to sglist / NULL on failure 3843 **/ 3844 static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len) 3845 { 3846 int sg_size, order; 3847 struct ipr_sglist *sglist; 3848 3849 /* Get the minimum size per scatter/gather element */ 3850 sg_size = buf_len / (IPR_MAX_SGLIST - 1); 3851 3852 /* Get the actual size per element */ 3853 order = get_order(sg_size); 3854 3855 /* Allocate a scatter/gather list for the DMA */ 3856 sglist = kzalloc(sizeof(struct ipr_sglist), GFP_KERNEL); 3857 if (sglist == NULL) { 3858 ipr_trace; 3859 return NULL; 3860 } 3861 sglist->order = order; 3862 sglist->scatterlist = sgl_alloc_order(buf_len, order, false, GFP_KERNEL, 3863 &sglist->num_sg); 3864 if (!sglist->scatterlist) { 3865 kfree(sglist); 3866 return NULL; 3867 } 3868 3869 return sglist; 3870 } 3871 3872 /** 3873 * ipr_free_ucode_buffer - Frees a microcode download buffer 3874 * @p_dnld: scatter/gather list pointer 3875 * 3876 * Free a DMA'able ucode download buffer previously allocated with 3877 * ipr_alloc_ucode_buffer 3878 * 3879 * Return value: 3880 * nothing 3881 **/ 3882 static void ipr_free_ucode_buffer(struct ipr_sglist *sglist) 3883 { 3884 sgl_free_order(sglist->scatterlist, sglist->order); 3885 kfree(sglist); 3886 } 3887 3888 /** 3889 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer 3890 * @sglist: scatter/gather list pointer 3891 * @buffer: buffer pointer 3892 * @len: buffer length 3893 * 3894 * Copy a microcode image from a user buffer into a buffer allocated by 3895 * ipr_alloc_ucode_buffer 3896 * 3897 * Return value: 3898 * 0 on success / other on failure 3899 **/ 3900 static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist, 3901 u8 *buffer, u32 len) 3902 { 3903 int bsize_elem, i, result = 0; 3904 struct scatterlist *scatterlist; 3905 void *kaddr; 3906 3907 /* Determine the actual number of bytes per element */ 3908 bsize_elem = PAGE_SIZE * (1 << sglist->order); 3909 3910 scatterlist = sglist->scatterlist; 3911 3912 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) { 3913 struct page *page = sg_page(&scatterlist[i]); 3914 3915 kaddr = kmap(page); 3916 memcpy(kaddr, buffer, bsize_elem); 3917 kunmap(page); 3918 3919 scatterlist[i].length = bsize_elem; 3920 3921 if (result != 0) { 3922 ipr_trace; 3923 return result; 3924 } 3925 } 3926 3927 if (len % bsize_elem) { 3928 struct page *page = sg_page(&scatterlist[i]); 3929 3930 kaddr = kmap(page); 3931 memcpy(kaddr, buffer, len % bsize_elem); 3932 kunmap(page); 3933 3934 scatterlist[i].length = len % bsize_elem; 3935 } 3936 3937 sglist->buffer_len = len; 3938 return result; 3939 } 3940 3941 /** 3942 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL 3943 * @ipr_cmd: ipr command struct 3944 * @sglist: scatter/gather list 3945 * 3946 * Builds a microcode download IOA data list (IOADL). 3947 * 3948 **/ 3949 static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd, 3950 struct ipr_sglist *sglist) 3951 { 3952 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 3953 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64; 3954 struct scatterlist *scatterlist = sglist->scatterlist; 3955 int i; 3956 3957 ipr_cmd->dma_use_sg = sglist->num_dma_sg; 3958 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 3959 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len); 3960 3961 ioarcb->ioadl_len = 3962 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); 3963 for (i = 0; i < ipr_cmd->dma_use_sg; i++) { 3964 ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE); 3965 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i])); 3966 ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i])); 3967 } 3968 3969 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); 3970 } 3971 3972 /** 3973 * ipr_build_ucode_ioadl - Build a microcode download IOADL 3974 * @ipr_cmd: ipr command struct 3975 * @sglist: scatter/gather list 3976 * 3977 * Builds a microcode download IOA data list (IOADL). 3978 * 3979 **/ 3980 static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd, 3981 struct ipr_sglist *sglist) 3982 { 3983 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 3984 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl; 3985 struct scatterlist *scatterlist = sglist->scatterlist; 3986 int i; 3987 3988 ipr_cmd->dma_use_sg = sglist->num_dma_sg; 3989 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 3990 ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len); 3991 3992 ioarcb->ioadl_len = 3993 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); 3994 3995 for (i = 0; i < ipr_cmd->dma_use_sg; i++) { 3996 ioadl[i].flags_and_data_len = 3997 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i])); 3998 ioadl[i].address = 3999 cpu_to_be32(sg_dma_address(&scatterlist[i])); 4000 } 4001 4002 ioadl[i-1].flags_and_data_len |= 4003 cpu_to_be32(IPR_IOADL_FLAGS_LAST); 4004 } 4005 4006 /** 4007 * ipr_update_ioa_ucode - Update IOA's microcode 4008 * @ioa_cfg: ioa config struct 4009 * @sglist: scatter/gather list 4010 * 4011 * Initiate an adapter reset to update the IOA's microcode 4012 * 4013 * Return value: 4014 * 0 on success / -EIO on failure 4015 **/ 4016 static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg, 4017 struct ipr_sglist *sglist) 4018 { 4019 unsigned long lock_flags; 4020 4021 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4022 while (ioa_cfg->in_reset_reload) { 4023 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4024 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 4025 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4026 } 4027 4028 if (ioa_cfg->ucode_sglist) { 4029 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4030 dev_err(&ioa_cfg->pdev->dev, 4031 "Microcode download already in progress\n"); 4032 return -EIO; 4033 } 4034 4035 sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev, 4036 sglist->scatterlist, sglist->num_sg, 4037 DMA_TO_DEVICE); 4038 4039 if (!sglist->num_dma_sg) { 4040 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4041 dev_err(&ioa_cfg->pdev->dev, 4042 "Failed to map microcode download buffer!\n"); 4043 return -EIO; 4044 } 4045 4046 ioa_cfg->ucode_sglist = sglist; 4047 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL); 4048 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4049 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 4050 4051 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4052 ioa_cfg->ucode_sglist = NULL; 4053 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4054 return 0; 4055 } 4056 4057 /** 4058 * ipr_store_update_fw - Update the firmware on the adapter 4059 * @class_dev: device struct 4060 * @buf: buffer 4061 * @count: buffer size 4062 * 4063 * This function will update the firmware on the adapter. 4064 * 4065 * Return value: 4066 * count on success / other on failure 4067 **/ 4068 static ssize_t ipr_store_update_fw(struct device *dev, 4069 struct device_attribute *attr, 4070 const char *buf, size_t count) 4071 { 4072 struct Scsi_Host *shost = class_to_shost(dev); 4073 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4074 struct ipr_ucode_image_header *image_hdr; 4075 const struct firmware *fw_entry; 4076 struct ipr_sglist *sglist; 4077 char fname[100]; 4078 char *src; 4079 char *endline; 4080 int result, dnld_size; 4081 4082 if (!capable(CAP_SYS_ADMIN)) 4083 return -EACCES; 4084 4085 snprintf(fname, sizeof(fname), "%s", buf); 4086 4087 endline = strchr(fname, '\n'); 4088 if (endline) 4089 *endline = '\0'; 4090 4091 if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) { 4092 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname); 4093 return -EIO; 4094 } 4095 4096 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data; 4097 4098 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length); 4099 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length); 4100 sglist = ipr_alloc_ucode_buffer(dnld_size); 4101 4102 if (!sglist) { 4103 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n"); 4104 release_firmware(fw_entry); 4105 return -ENOMEM; 4106 } 4107 4108 result = ipr_copy_ucode_buffer(sglist, src, dnld_size); 4109 4110 if (result) { 4111 dev_err(&ioa_cfg->pdev->dev, 4112 "Microcode buffer copy to DMA buffer failed\n"); 4113 goto out; 4114 } 4115 4116 ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n"); 4117 4118 result = ipr_update_ioa_ucode(ioa_cfg, sglist); 4119 4120 if (!result) 4121 result = count; 4122 out: 4123 ipr_free_ucode_buffer(sglist); 4124 release_firmware(fw_entry); 4125 return result; 4126 } 4127 4128 static struct device_attribute ipr_update_fw_attr = { 4129 .attr = { 4130 .name = "update_fw", 4131 .mode = S_IWUSR, 4132 }, 4133 .store = ipr_store_update_fw 4134 }; 4135 4136 /** 4137 * ipr_show_fw_type - Show the adapter's firmware type. 4138 * @dev: class device struct 4139 * @buf: buffer 4140 * 4141 * Return value: 4142 * number of bytes printed to buffer 4143 **/ 4144 static ssize_t ipr_show_fw_type(struct device *dev, 4145 struct device_attribute *attr, char *buf) 4146 { 4147 struct Scsi_Host *shost = class_to_shost(dev); 4148 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4149 unsigned long lock_flags = 0; 4150 int len; 4151 4152 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4153 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64); 4154 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4155 return len; 4156 } 4157 4158 static struct device_attribute ipr_ioa_fw_type_attr = { 4159 .attr = { 4160 .name = "fw_type", 4161 .mode = S_IRUGO, 4162 }, 4163 .show = ipr_show_fw_type 4164 }; 4165 4166 static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj, 4167 struct bin_attribute *bin_attr, char *buf, 4168 loff_t off, size_t count) 4169 { 4170 struct device *cdev = container_of(kobj, struct device, kobj); 4171 struct Scsi_Host *shost = class_to_shost(cdev); 4172 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4173 struct ipr_hostrcb *hostrcb; 4174 unsigned long lock_flags = 0; 4175 int ret; 4176 4177 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4178 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q, 4179 struct ipr_hostrcb, queue); 4180 if (!hostrcb) { 4181 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4182 return 0; 4183 } 4184 ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam, 4185 sizeof(hostrcb->hcam)); 4186 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4187 return ret; 4188 } 4189 4190 static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj, 4191 struct bin_attribute *bin_attr, char *buf, 4192 loff_t off, size_t count) 4193 { 4194 struct device *cdev = container_of(kobj, struct device, kobj); 4195 struct Scsi_Host *shost = class_to_shost(cdev); 4196 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4197 struct ipr_hostrcb *hostrcb; 4198 unsigned long lock_flags = 0; 4199 4200 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4201 hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q, 4202 struct ipr_hostrcb, queue); 4203 if (!hostrcb) { 4204 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4205 return count; 4206 } 4207 4208 /* Reclaim hostrcb before exit */ 4209 list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q); 4210 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4211 return count; 4212 } 4213 4214 static struct bin_attribute ipr_ioa_async_err_log = { 4215 .attr = { 4216 .name = "async_err_log", 4217 .mode = S_IRUGO | S_IWUSR, 4218 }, 4219 .size = 0, 4220 .read = ipr_read_async_err_log, 4221 .write = ipr_next_async_err_log 4222 }; 4223 4224 static struct device_attribute *ipr_ioa_attrs[] = { 4225 &ipr_fw_version_attr, 4226 &ipr_log_level_attr, 4227 &ipr_diagnostics_attr, 4228 &ipr_ioa_state_attr, 4229 &ipr_ioa_reset_attr, 4230 &ipr_update_fw_attr, 4231 &ipr_ioa_fw_type_attr, 4232 &ipr_iopoll_weight_attr, 4233 NULL, 4234 }; 4235 4236 #ifdef CONFIG_SCSI_IPR_DUMP 4237 /** 4238 * ipr_read_dump - Dump the adapter 4239 * @filp: open sysfs file 4240 * @kobj: kobject struct 4241 * @bin_attr: bin_attribute struct 4242 * @buf: buffer 4243 * @off: offset 4244 * @count: buffer size 4245 * 4246 * Return value: 4247 * number of bytes printed to buffer 4248 **/ 4249 static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj, 4250 struct bin_attribute *bin_attr, 4251 char *buf, loff_t off, size_t count) 4252 { 4253 struct device *cdev = container_of(kobj, struct device, kobj); 4254 struct Scsi_Host *shost = class_to_shost(cdev); 4255 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4256 struct ipr_dump *dump; 4257 unsigned long lock_flags = 0; 4258 char *src; 4259 int len, sdt_end; 4260 size_t rc = count; 4261 4262 if (!capable(CAP_SYS_ADMIN)) 4263 return -EACCES; 4264 4265 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4266 dump = ioa_cfg->dump; 4267 4268 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) { 4269 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4270 return 0; 4271 } 4272 kref_get(&dump->kref); 4273 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4274 4275 if (off > dump->driver_dump.hdr.len) { 4276 kref_put(&dump->kref, ipr_release_dump); 4277 return 0; 4278 } 4279 4280 if (off + count > dump->driver_dump.hdr.len) { 4281 count = dump->driver_dump.hdr.len - off; 4282 rc = count; 4283 } 4284 4285 if (count && off < sizeof(dump->driver_dump)) { 4286 if (off + count > sizeof(dump->driver_dump)) 4287 len = sizeof(dump->driver_dump) - off; 4288 else 4289 len = count; 4290 src = (u8 *)&dump->driver_dump + off; 4291 memcpy(buf, src, len); 4292 buf += len; 4293 off += len; 4294 count -= len; 4295 } 4296 4297 off -= sizeof(dump->driver_dump); 4298 4299 if (ioa_cfg->sis64) 4300 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) + 4301 (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) * 4302 sizeof(struct ipr_sdt_entry)); 4303 else 4304 sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) + 4305 (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry)); 4306 4307 if (count && off < sdt_end) { 4308 if (off + count > sdt_end) 4309 len = sdt_end - off; 4310 else 4311 len = count; 4312 src = (u8 *)&dump->ioa_dump + off; 4313 memcpy(buf, src, len); 4314 buf += len; 4315 off += len; 4316 count -= len; 4317 } 4318 4319 off -= sdt_end; 4320 4321 while (count) { 4322 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK)) 4323 len = PAGE_ALIGN(off) - off; 4324 else 4325 len = count; 4326 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT]; 4327 src += off & ~PAGE_MASK; 4328 memcpy(buf, src, len); 4329 buf += len; 4330 off += len; 4331 count -= len; 4332 } 4333 4334 kref_put(&dump->kref, ipr_release_dump); 4335 return rc; 4336 } 4337 4338 /** 4339 * ipr_alloc_dump - Prepare for adapter dump 4340 * @ioa_cfg: ioa config struct 4341 * 4342 * Return value: 4343 * 0 on success / other on failure 4344 **/ 4345 static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg) 4346 { 4347 struct ipr_dump *dump; 4348 __be32 **ioa_data; 4349 unsigned long lock_flags = 0; 4350 4351 dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL); 4352 4353 if (!dump) { 4354 ipr_err("Dump memory allocation failed\n"); 4355 return -ENOMEM; 4356 } 4357 4358 if (ioa_cfg->sis64) 4359 ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES, 4360 sizeof(__be32 *))); 4361 else 4362 ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES, 4363 sizeof(__be32 *))); 4364 4365 if (!ioa_data) { 4366 ipr_err("Dump memory allocation failed\n"); 4367 kfree(dump); 4368 return -ENOMEM; 4369 } 4370 4371 dump->ioa_dump.ioa_data = ioa_data; 4372 4373 kref_init(&dump->kref); 4374 dump->ioa_cfg = ioa_cfg; 4375 4376 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4377 4378 if (INACTIVE != ioa_cfg->sdt_state) { 4379 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4380 vfree(dump->ioa_dump.ioa_data); 4381 kfree(dump); 4382 return 0; 4383 } 4384 4385 ioa_cfg->dump = dump; 4386 ioa_cfg->sdt_state = WAIT_FOR_DUMP; 4387 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) { 4388 ioa_cfg->dump_taken = 1; 4389 schedule_work(&ioa_cfg->work_q); 4390 } 4391 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4392 4393 return 0; 4394 } 4395 4396 /** 4397 * ipr_free_dump - Free adapter dump memory 4398 * @ioa_cfg: ioa config struct 4399 * 4400 * Return value: 4401 * 0 on success / other on failure 4402 **/ 4403 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) 4404 { 4405 struct ipr_dump *dump; 4406 unsigned long lock_flags = 0; 4407 4408 ENTER; 4409 4410 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4411 dump = ioa_cfg->dump; 4412 if (!dump) { 4413 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4414 return 0; 4415 } 4416 4417 ioa_cfg->dump = NULL; 4418 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4419 4420 kref_put(&dump->kref, ipr_release_dump); 4421 4422 LEAVE; 4423 return 0; 4424 } 4425 4426 /** 4427 * ipr_write_dump - Setup dump state of adapter 4428 * @filp: open sysfs file 4429 * @kobj: kobject struct 4430 * @bin_attr: bin_attribute struct 4431 * @buf: buffer 4432 * @off: offset 4433 * @count: buffer size 4434 * 4435 * Return value: 4436 * number of bytes printed to buffer 4437 **/ 4438 static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj, 4439 struct bin_attribute *bin_attr, 4440 char *buf, loff_t off, size_t count) 4441 { 4442 struct device *cdev = container_of(kobj, struct device, kobj); 4443 struct Scsi_Host *shost = class_to_shost(cdev); 4444 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 4445 int rc; 4446 4447 if (!capable(CAP_SYS_ADMIN)) 4448 return -EACCES; 4449 4450 if (buf[0] == '1') 4451 rc = ipr_alloc_dump(ioa_cfg); 4452 else if (buf[0] == '0') 4453 rc = ipr_free_dump(ioa_cfg); 4454 else 4455 return -EINVAL; 4456 4457 if (rc) 4458 return rc; 4459 else 4460 return count; 4461 } 4462 4463 static struct bin_attribute ipr_dump_attr = { 4464 .attr = { 4465 .name = "dump", 4466 .mode = S_IRUSR | S_IWUSR, 4467 }, 4468 .size = 0, 4469 .read = ipr_read_dump, 4470 .write = ipr_write_dump 4471 }; 4472 #else 4473 static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; }; 4474 #endif 4475 4476 /** 4477 * ipr_change_queue_depth - Change the device's queue depth 4478 * @sdev: scsi device struct 4479 * @qdepth: depth to set 4480 * @reason: calling context 4481 * 4482 * Return value: 4483 * actual depth set 4484 **/ 4485 static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth) 4486 { 4487 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4488 struct ipr_resource_entry *res; 4489 unsigned long lock_flags = 0; 4490 4491 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4492 res = (struct ipr_resource_entry *)sdev->hostdata; 4493 4494 if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN) 4495 qdepth = IPR_MAX_CMD_PER_ATA_LUN; 4496 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4497 4498 scsi_change_queue_depth(sdev, qdepth); 4499 return sdev->queue_depth; 4500 } 4501 4502 /** 4503 * ipr_show_adapter_handle - Show the adapter's resource handle for this device 4504 * @dev: device struct 4505 * @attr: device attribute structure 4506 * @buf: buffer 4507 * 4508 * Return value: 4509 * number of bytes printed to buffer 4510 **/ 4511 static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf) 4512 { 4513 struct scsi_device *sdev = to_scsi_device(dev); 4514 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4515 struct ipr_resource_entry *res; 4516 unsigned long lock_flags = 0; 4517 ssize_t len = -ENXIO; 4518 4519 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4520 res = (struct ipr_resource_entry *)sdev->hostdata; 4521 if (res) 4522 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle); 4523 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4524 return len; 4525 } 4526 4527 static struct device_attribute ipr_adapter_handle_attr = { 4528 .attr = { 4529 .name = "adapter_handle", 4530 .mode = S_IRUSR, 4531 }, 4532 .show = ipr_show_adapter_handle 4533 }; 4534 4535 /** 4536 * ipr_show_resource_path - Show the resource path or the resource address for 4537 * this device. 4538 * @dev: device struct 4539 * @attr: device attribute structure 4540 * @buf: buffer 4541 * 4542 * Return value: 4543 * number of bytes printed to buffer 4544 **/ 4545 static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf) 4546 { 4547 struct scsi_device *sdev = to_scsi_device(dev); 4548 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4549 struct ipr_resource_entry *res; 4550 unsigned long lock_flags = 0; 4551 ssize_t len = -ENXIO; 4552 char buffer[IPR_MAX_RES_PATH_LENGTH]; 4553 4554 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4555 res = (struct ipr_resource_entry *)sdev->hostdata; 4556 if (res && ioa_cfg->sis64) 4557 len = snprintf(buf, PAGE_SIZE, "%s\n", 4558 __ipr_format_res_path(res->res_path, buffer, 4559 sizeof(buffer))); 4560 else if (res) 4561 len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no, 4562 res->bus, res->target, res->lun); 4563 4564 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4565 return len; 4566 } 4567 4568 static struct device_attribute ipr_resource_path_attr = { 4569 .attr = { 4570 .name = "resource_path", 4571 .mode = S_IRUGO, 4572 }, 4573 .show = ipr_show_resource_path 4574 }; 4575 4576 /** 4577 * ipr_show_device_id - Show the device_id for this device. 4578 * @dev: device struct 4579 * @attr: device attribute structure 4580 * @buf: buffer 4581 * 4582 * Return value: 4583 * number of bytes printed to buffer 4584 **/ 4585 static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf) 4586 { 4587 struct scsi_device *sdev = to_scsi_device(dev); 4588 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4589 struct ipr_resource_entry *res; 4590 unsigned long lock_flags = 0; 4591 ssize_t len = -ENXIO; 4592 4593 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4594 res = (struct ipr_resource_entry *)sdev->hostdata; 4595 if (res && ioa_cfg->sis64) 4596 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id)); 4597 else if (res) 4598 len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn); 4599 4600 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4601 return len; 4602 } 4603 4604 static struct device_attribute ipr_device_id_attr = { 4605 .attr = { 4606 .name = "device_id", 4607 .mode = S_IRUGO, 4608 }, 4609 .show = ipr_show_device_id 4610 }; 4611 4612 /** 4613 * ipr_show_resource_type - Show the resource type for this device. 4614 * @dev: device struct 4615 * @attr: device attribute structure 4616 * @buf: buffer 4617 * 4618 * Return value: 4619 * number of bytes printed to buffer 4620 **/ 4621 static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf) 4622 { 4623 struct scsi_device *sdev = to_scsi_device(dev); 4624 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4625 struct ipr_resource_entry *res; 4626 unsigned long lock_flags = 0; 4627 ssize_t len = -ENXIO; 4628 4629 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4630 res = (struct ipr_resource_entry *)sdev->hostdata; 4631 4632 if (res) 4633 len = snprintf(buf, PAGE_SIZE, "%x\n", res->type); 4634 4635 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4636 return len; 4637 } 4638 4639 static struct device_attribute ipr_resource_type_attr = { 4640 .attr = { 4641 .name = "resource_type", 4642 .mode = S_IRUGO, 4643 }, 4644 .show = ipr_show_resource_type 4645 }; 4646 4647 /** 4648 * ipr_show_raw_mode - Show the adapter's raw mode 4649 * @dev: class device struct 4650 * @buf: buffer 4651 * 4652 * Return value: 4653 * number of bytes printed to buffer 4654 **/ 4655 static ssize_t ipr_show_raw_mode(struct device *dev, 4656 struct device_attribute *attr, char *buf) 4657 { 4658 struct scsi_device *sdev = to_scsi_device(dev); 4659 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4660 struct ipr_resource_entry *res; 4661 unsigned long lock_flags = 0; 4662 ssize_t len; 4663 4664 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4665 res = (struct ipr_resource_entry *)sdev->hostdata; 4666 if (res) 4667 len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode); 4668 else 4669 len = -ENXIO; 4670 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4671 return len; 4672 } 4673 4674 /** 4675 * ipr_store_raw_mode - Change the adapter's raw mode 4676 * @dev: class device struct 4677 * @buf: buffer 4678 * 4679 * Return value: 4680 * number of bytes printed to buffer 4681 **/ 4682 static ssize_t ipr_store_raw_mode(struct device *dev, 4683 struct device_attribute *attr, 4684 const char *buf, size_t count) 4685 { 4686 struct scsi_device *sdev = to_scsi_device(dev); 4687 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata; 4688 struct ipr_resource_entry *res; 4689 unsigned long lock_flags = 0; 4690 ssize_t len; 4691 4692 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4693 res = (struct ipr_resource_entry *)sdev->hostdata; 4694 if (res) { 4695 if (ipr_is_af_dasd_device(res)) { 4696 res->raw_mode = simple_strtoul(buf, NULL, 10); 4697 len = strlen(buf); 4698 if (res->sdev) 4699 sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n", 4700 res->raw_mode ? "enabled" : "disabled"); 4701 } else 4702 len = -EINVAL; 4703 } else 4704 len = -ENXIO; 4705 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4706 return len; 4707 } 4708 4709 static struct device_attribute ipr_raw_mode_attr = { 4710 .attr = { 4711 .name = "raw_mode", 4712 .mode = S_IRUGO | S_IWUSR, 4713 }, 4714 .show = ipr_show_raw_mode, 4715 .store = ipr_store_raw_mode 4716 }; 4717 4718 static struct device_attribute *ipr_dev_attrs[] = { 4719 &ipr_adapter_handle_attr, 4720 &ipr_resource_path_attr, 4721 &ipr_device_id_attr, 4722 &ipr_resource_type_attr, 4723 &ipr_raw_mode_attr, 4724 NULL, 4725 }; 4726 4727 /** 4728 * ipr_biosparam - Return the HSC mapping 4729 * @sdev: scsi device struct 4730 * @block_device: block device pointer 4731 * @capacity: capacity of the device 4732 * @parm: Array containing returned HSC values. 4733 * 4734 * This function generates the HSC parms that fdisk uses. 4735 * We want to make sure we return something that places partitions 4736 * on 4k boundaries for best performance with the IOA. 4737 * 4738 * Return value: 4739 * 0 on success 4740 **/ 4741 static int ipr_biosparam(struct scsi_device *sdev, 4742 struct block_device *block_device, 4743 sector_t capacity, int *parm) 4744 { 4745 int heads, sectors; 4746 sector_t cylinders; 4747 4748 heads = 128; 4749 sectors = 32; 4750 4751 cylinders = capacity; 4752 sector_div(cylinders, (128 * 32)); 4753 4754 /* return result */ 4755 parm[0] = heads; 4756 parm[1] = sectors; 4757 parm[2] = cylinders; 4758 4759 return 0; 4760 } 4761 4762 /** 4763 * ipr_find_starget - Find target based on bus/target. 4764 * @starget: scsi target struct 4765 * 4766 * Return value: 4767 * resource entry pointer if found / NULL if not found 4768 **/ 4769 static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget) 4770 { 4771 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 4772 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata; 4773 struct ipr_resource_entry *res; 4774 4775 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) { 4776 if ((res->bus == starget->channel) && 4777 (res->target == starget->id)) { 4778 return res; 4779 } 4780 } 4781 4782 return NULL; 4783 } 4784 4785 static struct ata_port_info sata_port_info; 4786 4787 /** 4788 * ipr_target_alloc - Prepare for commands to a SCSI target 4789 * @starget: scsi target struct 4790 * 4791 * If the device is a SATA device, this function allocates an 4792 * ATA port with libata, else it does nothing. 4793 * 4794 * Return value: 4795 * 0 on success / non-0 on failure 4796 **/ 4797 static int ipr_target_alloc(struct scsi_target *starget) 4798 { 4799 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 4800 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata; 4801 struct ipr_sata_port *sata_port; 4802 struct ata_port *ap; 4803 struct ipr_resource_entry *res; 4804 unsigned long lock_flags; 4805 4806 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4807 res = ipr_find_starget(starget); 4808 starget->hostdata = NULL; 4809 4810 if (res && ipr_is_gata(res)) { 4811 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4812 sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL); 4813 if (!sata_port) 4814 return -ENOMEM; 4815 4816 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost); 4817 if (ap) { 4818 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4819 sata_port->ioa_cfg = ioa_cfg; 4820 sata_port->ap = ap; 4821 sata_port->res = res; 4822 4823 res->sata_port = sata_port; 4824 ap->private_data = sata_port; 4825 starget->hostdata = sata_port; 4826 } else { 4827 kfree(sata_port); 4828 return -ENOMEM; 4829 } 4830 } 4831 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4832 4833 return 0; 4834 } 4835 4836 /** 4837 * ipr_target_destroy - Destroy a SCSI target 4838 * @starget: scsi target struct 4839 * 4840 * If the device was a SATA device, this function frees the libata 4841 * ATA port, else it does nothing. 4842 * 4843 **/ 4844 static void ipr_target_destroy(struct scsi_target *starget) 4845 { 4846 struct ipr_sata_port *sata_port = starget->hostdata; 4847 struct Scsi_Host *shost = dev_to_shost(&starget->dev); 4848 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata; 4849 4850 if (ioa_cfg->sis64) { 4851 if (!ipr_find_starget(starget)) { 4852 if (starget->channel == IPR_ARRAY_VIRTUAL_BUS) 4853 clear_bit(starget->id, ioa_cfg->array_ids); 4854 else if (starget->channel == IPR_VSET_VIRTUAL_BUS) 4855 clear_bit(starget->id, ioa_cfg->vset_ids); 4856 else if (starget->channel == 0) 4857 clear_bit(starget->id, ioa_cfg->target_ids); 4858 } 4859 } 4860 4861 if (sata_port) { 4862 starget->hostdata = NULL; 4863 ata_sas_port_destroy(sata_port->ap); 4864 kfree(sata_port); 4865 } 4866 } 4867 4868 /** 4869 * ipr_find_sdev - Find device based on bus/target/lun. 4870 * @sdev: scsi device struct 4871 * 4872 * Return value: 4873 * resource entry pointer if found / NULL if not found 4874 **/ 4875 static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev) 4876 { 4877 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata; 4878 struct ipr_resource_entry *res; 4879 4880 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) { 4881 if ((res->bus == sdev->channel) && 4882 (res->target == sdev->id) && 4883 (res->lun == sdev->lun)) 4884 return res; 4885 } 4886 4887 return NULL; 4888 } 4889 4890 /** 4891 * ipr_slave_destroy - Unconfigure a SCSI device 4892 * @sdev: scsi device struct 4893 * 4894 * Return value: 4895 * nothing 4896 **/ 4897 static void ipr_slave_destroy(struct scsi_device *sdev) 4898 { 4899 struct ipr_resource_entry *res; 4900 struct ipr_ioa_cfg *ioa_cfg; 4901 unsigned long lock_flags = 0; 4902 4903 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata; 4904 4905 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4906 res = (struct ipr_resource_entry *) sdev->hostdata; 4907 if (res) { 4908 if (res->sata_port) 4909 res->sata_port->ap->link.device[0].class = ATA_DEV_NONE; 4910 sdev->hostdata = NULL; 4911 res->sdev = NULL; 4912 res->sata_port = NULL; 4913 } 4914 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4915 } 4916 4917 /** 4918 * ipr_slave_configure - Configure a SCSI device 4919 * @sdev: scsi device struct 4920 * 4921 * This function configures the specified scsi device. 4922 * 4923 * Return value: 4924 * 0 on success 4925 **/ 4926 static int ipr_slave_configure(struct scsi_device *sdev) 4927 { 4928 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata; 4929 struct ipr_resource_entry *res; 4930 struct ata_port *ap = NULL; 4931 unsigned long lock_flags = 0; 4932 char buffer[IPR_MAX_RES_PATH_LENGTH]; 4933 4934 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 4935 res = sdev->hostdata; 4936 if (res) { 4937 if (ipr_is_af_dasd_device(res)) 4938 sdev->type = TYPE_RAID; 4939 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) { 4940 sdev->scsi_level = 4; 4941 sdev->no_uld_attach = 1; 4942 } 4943 if (ipr_is_vset_device(res)) { 4944 sdev->scsi_level = SCSI_SPC_3; 4945 sdev->no_report_opcodes = 1; 4946 blk_queue_rq_timeout(sdev->request_queue, 4947 IPR_VSET_RW_TIMEOUT); 4948 blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS); 4949 } 4950 if (ipr_is_gata(res) && res->sata_port) 4951 ap = res->sata_port->ap; 4952 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4953 4954 if (ap) { 4955 scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN); 4956 ata_sas_slave_configure(sdev, ap); 4957 } 4958 4959 if (ioa_cfg->sis64) 4960 sdev_printk(KERN_INFO, sdev, "Resource path: %s\n", 4961 ipr_format_res_path(ioa_cfg, 4962 res->res_path, buffer, sizeof(buffer))); 4963 return 0; 4964 } 4965 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 4966 return 0; 4967 } 4968 4969 /** 4970 * ipr_ata_slave_alloc - Prepare for commands to a SATA device 4971 * @sdev: scsi device struct 4972 * 4973 * This function initializes an ATA port so that future commands 4974 * sent through queuecommand will work. 4975 * 4976 * Return value: 4977 * 0 on success 4978 **/ 4979 static int ipr_ata_slave_alloc(struct scsi_device *sdev) 4980 { 4981 struct ipr_sata_port *sata_port = NULL; 4982 int rc = -ENXIO; 4983 4984 ENTER; 4985 if (sdev->sdev_target) 4986 sata_port = sdev->sdev_target->hostdata; 4987 if (sata_port) { 4988 rc = ata_sas_port_init(sata_port->ap); 4989 if (rc == 0) 4990 rc = ata_sas_sync_probe(sata_port->ap); 4991 } 4992 4993 if (rc) 4994 ipr_slave_destroy(sdev); 4995 4996 LEAVE; 4997 return rc; 4998 } 4999 5000 /** 5001 * ipr_slave_alloc - Prepare for commands to a device. 5002 * @sdev: scsi device struct 5003 * 5004 * This function saves a pointer to the resource entry 5005 * in the scsi device struct if the device exists. We 5006 * can then use this pointer in ipr_queuecommand when 5007 * handling new commands. 5008 * 5009 * Return value: 5010 * 0 on success / -ENXIO if device does not exist 5011 **/ 5012 static int ipr_slave_alloc(struct scsi_device *sdev) 5013 { 5014 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata; 5015 struct ipr_resource_entry *res; 5016 unsigned long lock_flags; 5017 int rc = -ENXIO; 5018 5019 sdev->hostdata = NULL; 5020 5021 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5022 5023 res = ipr_find_sdev(sdev); 5024 if (res) { 5025 res->sdev = sdev; 5026 res->add_to_ml = 0; 5027 res->in_erp = 0; 5028 sdev->hostdata = res; 5029 if (!ipr_is_naca_model(res)) 5030 res->needs_sync_complete = 1; 5031 rc = 0; 5032 if (ipr_is_gata(res)) { 5033 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5034 return ipr_ata_slave_alloc(sdev); 5035 } 5036 } 5037 5038 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5039 5040 return rc; 5041 } 5042 5043 /** 5044 * ipr_match_lun - Match function for specified LUN 5045 * @ipr_cmd: ipr command struct 5046 * @device: device to match (sdev) 5047 * 5048 * Returns: 5049 * 1 if command matches sdev / 0 if command does not match sdev 5050 **/ 5051 static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device) 5052 { 5053 if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device) 5054 return 1; 5055 return 0; 5056 } 5057 5058 /** 5059 * ipr_cmnd_is_free - Check if a command is free or not 5060 * @ipr_cmd ipr command struct 5061 * 5062 * Returns: 5063 * true / false 5064 **/ 5065 static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd) 5066 { 5067 struct ipr_cmnd *loop_cmd; 5068 5069 list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) { 5070 if (loop_cmd == ipr_cmd) 5071 return true; 5072 } 5073 5074 return false; 5075 } 5076 5077 /** 5078 * ipr_match_res - Match function for specified resource entry 5079 * @ipr_cmd: ipr command struct 5080 * @resource: resource entry to match 5081 * 5082 * Returns: 5083 * 1 if command matches sdev / 0 if command does not match sdev 5084 **/ 5085 static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource) 5086 { 5087 struct ipr_resource_entry *res = resource; 5088 5089 if (res && ipr_cmd->ioarcb.res_handle == res->res_handle) 5090 return 1; 5091 return 0; 5092 } 5093 5094 /** 5095 * ipr_wait_for_ops - Wait for matching commands to complete 5096 * @ipr_cmd: ipr command struct 5097 * @device: device to match (sdev) 5098 * @match: match function to use 5099 * 5100 * Returns: 5101 * SUCCESS / FAILED 5102 **/ 5103 static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device, 5104 int (*match)(struct ipr_cmnd *, void *)) 5105 { 5106 struct ipr_cmnd *ipr_cmd; 5107 int wait, i; 5108 unsigned long flags; 5109 struct ipr_hrr_queue *hrrq; 5110 signed long timeout = IPR_ABORT_TASK_TIMEOUT; 5111 DECLARE_COMPLETION_ONSTACK(comp); 5112 5113 ENTER; 5114 do { 5115 wait = 0; 5116 5117 for_each_hrrq(hrrq, ioa_cfg) { 5118 spin_lock_irqsave(hrrq->lock, flags); 5119 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) { 5120 ipr_cmd = ioa_cfg->ipr_cmnd_list[i]; 5121 if (!ipr_cmnd_is_free(ipr_cmd)) { 5122 if (match(ipr_cmd, device)) { 5123 ipr_cmd->eh_comp = ∁ 5124 wait++; 5125 } 5126 } 5127 } 5128 spin_unlock_irqrestore(hrrq->lock, flags); 5129 } 5130 5131 if (wait) { 5132 timeout = wait_for_completion_timeout(&comp, timeout); 5133 5134 if (!timeout) { 5135 wait = 0; 5136 5137 for_each_hrrq(hrrq, ioa_cfg) { 5138 spin_lock_irqsave(hrrq->lock, flags); 5139 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) { 5140 ipr_cmd = ioa_cfg->ipr_cmnd_list[i]; 5141 if (!ipr_cmnd_is_free(ipr_cmd)) { 5142 if (match(ipr_cmd, device)) { 5143 ipr_cmd->eh_comp = NULL; 5144 wait++; 5145 } 5146 } 5147 } 5148 spin_unlock_irqrestore(hrrq->lock, flags); 5149 } 5150 5151 if (wait) 5152 dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n"); 5153 LEAVE; 5154 return wait ? FAILED : SUCCESS; 5155 } 5156 } 5157 } while (wait); 5158 5159 LEAVE; 5160 return SUCCESS; 5161 } 5162 5163 static int ipr_eh_host_reset(struct scsi_cmnd *cmd) 5164 { 5165 struct ipr_ioa_cfg *ioa_cfg; 5166 unsigned long lock_flags = 0; 5167 int rc = SUCCESS; 5168 5169 ENTER; 5170 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata; 5171 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5172 5173 if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) { 5174 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV); 5175 dev_err(&ioa_cfg->pdev->dev, 5176 "Adapter being reset as a result of error recovery.\n"); 5177 5178 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state) 5179 ioa_cfg->sdt_state = GET_DUMP; 5180 } 5181 5182 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5183 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 5184 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5185 5186 /* If we got hit with a host reset while we were already resetting 5187 the adapter for some reason, and the reset failed. */ 5188 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) { 5189 ipr_trace; 5190 rc = FAILED; 5191 } 5192 5193 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5194 LEAVE; 5195 return rc; 5196 } 5197 5198 /** 5199 * ipr_device_reset - Reset the device 5200 * @ioa_cfg: ioa config struct 5201 * @res: resource entry struct 5202 * 5203 * This function issues a device reset to the affected device. 5204 * If the device is a SCSI device, a LUN reset will be sent 5205 * to the device first. If that does not work, a target reset 5206 * will be sent. If the device is a SATA device, a PHY reset will 5207 * be sent. 5208 * 5209 * Return value: 5210 * 0 on success / non-zero on failure 5211 **/ 5212 static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg, 5213 struct ipr_resource_entry *res) 5214 { 5215 struct ipr_cmnd *ipr_cmd; 5216 struct ipr_ioarcb *ioarcb; 5217 struct ipr_cmd_pkt *cmd_pkt; 5218 struct ipr_ioarcb_ata_regs *regs; 5219 u32 ioasc; 5220 5221 ENTER; 5222 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg); 5223 ioarcb = &ipr_cmd->ioarcb; 5224 cmd_pkt = &ioarcb->cmd_pkt; 5225 5226 if (ipr_cmd->ioa_cfg->sis64) { 5227 regs = &ipr_cmd->i.ata_ioadl.regs; 5228 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb)); 5229 } else 5230 regs = &ioarcb->u.add_data.u.regs; 5231 5232 ioarcb->res_handle = res->res_handle; 5233 cmd_pkt->request_type = IPR_RQTYPE_IOACMD; 5234 cmd_pkt->cdb[0] = IPR_RESET_DEVICE; 5235 if (ipr_is_gata(res)) { 5236 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET; 5237 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags)); 5238 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION; 5239 } 5240 5241 ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT); 5242 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 5243 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 5244 if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) { 5245 if (ipr_cmd->ioa_cfg->sis64) 5246 memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata, 5247 sizeof(struct ipr_ioasa_gata)); 5248 else 5249 memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata, 5250 sizeof(struct ipr_ioasa_gata)); 5251 } 5252 5253 LEAVE; 5254 return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0; 5255 } 5256 5257 /** 5258 * ipr_sata_reset - Reset the SATA port 5259 * @link: SATA link to reset 5260 * @classes: class of the attached device 5261 * 5262 * This function issues a SATA phy reset to the affected ATA link. 5263 * 5264 * Return value: 5265 * 0 on success / non-zero on failure 5266 **/ 5267 static int ipr_sata_reset(struct ata_link *link, unsigned int *classes, 5268 unsigned long deadline) 5269 { 5270 struct ipr_sata_port *sata_port = link->ap->private_data; 5271 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg; 5272 struct ipr_resource_entry *res; 5273 unsigned long lock_flags = 0; 5274 int rc = -ENXIO, ret; 5275 5276 ENTER; 5277 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5278 while (ioa_cfg->in_reset_reload) { 5279 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5280 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 5281 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5282 } 5283 5284 res = sata_port->res; 5285 if (res) { 5286 rc = ipr_device_reset(ioa_cfg, res); 5287 *classes = res->ata_class; 5288 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5289 5290 ret = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res); 5291 if (ret != SUCCESS) { 5292 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5293 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV); 5294 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5295 5296 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 5297 } 5298 } else 5299 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5300 5301 LEAVE; 5302 return rc; 5303 } 5304 5305 /** 5306 * ipr_eh_dev_reset - Reset the device 5307 * @scsi_cmd: scsi command struct 5308 * 5309 * This function issues a device reset to the affected device. 5310 * A LUN reset will be sent to the device first. If that does 5311 * not work, a target reset will be sent. 5312 * 5313 * Return value: 5314 * SUCCESS / FAILED 5315 **/ 5316 static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd) 5317 { 5318 struct ipr_cmnd *ipr_cmd; 5319 struct ipr_ioa_cfg *ioa_cfg; 5320 struct ipr_resource_entry *res; 5321 struct ata_port *ap; 5322 int rc = 0, i; 5323 struct ipr_hrr_queue *hrrq; 5324 5325 ENTER; 5326 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata; 5327 res = scsi_cmd->device->hostdata; 5328 5329 /* 5330 * If we are currently going through reset/reload, return failed. This will force the 5331 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the 5332 * reset to complete 5333 */ 5334 if (ioa_cfg->in_reset_reload) 5335 return FAILED; 5336 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) 5337 return FAILED; 5338 5339 for_each_hrrq(hrrq, ioa_cfg) { 5340 spin_lock(&hrrq->_lock); 5341 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) { 5342 ipr_cmd = ioa_cfg->ipr_cmnd_list[i]; 5343 5344 if (ipr_cmd->ioarcb.res_handle == res->res_handle) { 5345 if (!ipr_cmd->qc) 5346 continue; 5347 if (ipr_cmnd_is_free(ipr_cmd)) 5348 continue; 5349 5350 ipr_cmd->done = ipr_sata_eh_done; 5351 if (!(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) { 5352 ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT; 5353 ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED; 5354 } 5355 } 5356 } 5357 spin_unlock(&hrrq->_lock); 5358 } 5359 res->resetting_device = 1; 5360 scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n"); 5361 5362 if (ipr_is_gata(res) && res->sata_port) { 5363 ap = res->sata_port->ap; 5364 spin_unlock_irq(scsi_cmd->device->host->host_lock); 5365 ata_std_error_handler(ap); 5366 spin_lock_irq(scsi_cmd->device->host->host_lock); 5367 } else 5368 rc = ipr_device_reset(ioa_cfg, res); 5369 res->resetting_device = 0; 5370 res->reset_occurred = 1; 5371 5372 LEAVE; 5373 return rc ? FAILED : SUCCESS; 5374 } 5375 5376 static int ipr_eh_dev_reset(struct scsi_cmnd *cmd) 5377 { 5378 int rc; 5379 struct ipr_ioa_cfg *ioa_cfg; 5380 struct ipr_resource_entry *res; 5381 5382 ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata; 5383 res = cmd->device->hostdata; 5384 5385 if (!res) 5386 return FAILED; 5387 5388 spin_lock_irq(cmd->device->host->host_lock); 5389 rc = __ipr_eh_dev_reset(cmd); 5390 spin_unlock_irq(cmd->device->host->host_lock); 5391 5392 if (rc == SUCCESS) { 5393 if (ipr_is_gata(res) && res->sata_port) 5394 rc = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res); 5395 else 5396 rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun); 5397 } 5398 5399 return rc; 5400 } 5401 5402 /** 5403 * ipr_bus_reset_done - Op done function for bus reset. 5404 * @ipr_cmd: ipr command struct 5405 * 5406 * This function is the op done function for a bus reset 5407 * 5408 * Return value: 5409 * none 5410 **/ 5411 static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd) 5412 { 5413 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 5414 struct ipr_resource_entry *res; 5415 5416 ENTER; 5417 if (!ioa_cfg->sis64) 5418 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) { 5419 if (res->res_handle == ipr_cmd->ioarcb.res_handle) { 5420 scsi_report_bus_reset(ioa_cfg->host, res->bus); 5421 break; 5422 } 5423 } 5424 5425 /* 5426 * If abort has not completed, indicate the reset has, else call the 5427 * abort's done function to wake the sleeping eh thread 5428 */ 5429 if (ipr_cmd->sibling->sibling) 5430 ipr_cmd->sibling->sibling = NULL; 5431 else 5432 ipr_cmd->sibling->done(ipr_cmd->sibling); 5433 5434 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 5435 LEAVE; 5436 } 5437 5438 /** 5439 * ipr_abort_timeout - An abort task has timed out 5440 * @ipr_cmd: ipr command struct 5441 * 5442 * This function handles when an abort task times out. If this 5443 * happens we issue a bus reset since we have resources tied 5444 * up that must be freed before returning to the midlayer. 5445 * 5446 * Return value: 5447 * none 5448 **/ 5449 static void ipr_abort_timeout(struct timer_list *t) 5450 { 5451 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 5452 struct ipr_cmnd *reset_cmd; 5453 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 5454 struct ipr_cmd_pkt *cmd_pkt; 5455 unsigned long lock_flags = 0; 5456 5457 ENTER; 5458 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 5459 if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) { 5460 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5461 return; 5462 } 5463 5464 sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n"); 5465 reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg); 5466 ipr_cmd->sibling = reset_cmd; 5467 reset_cmd->sibling = ipr_cmd; 5468 reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle; 5469 cmd_pkt = &reset_cmd->ioarcb.cmd_pkt; 5470 cmd_pkt->request_type = IPR_RQTYPE_IOACMD; 5471 cmd_pkt->cdb[0] = IPR_RESET_DEVICE; 5472 cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET; 5473 5474 ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT); 5475 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 5476 LEAVE; 5477 } 5478 5479 /** 5480 * ipr_cancel_op - Cancel specified op 5481 * @scsi_cmd: scsi command struct 5482 * 5483 * This function cancels specified op. 5484 * 5485 * Return value: 5486 * SUCCESS / FAILED 5487 **/ 5488 static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd) 5489 { 5490 struct ipr_cmnd *ipr_cmd; 5491 struct ipr_ioa_cfg *ioa_cfg; 5492 struct ipr_resource_entry *res; 5493 struct ipr_cmd_pkt *cmd_pkt; 5494 u32 ioasc, int_reg; 5495 int i, op_found = 0; 5496 struct ipr_hrr_queue *hrrq; 5497 5498 ENTER; 5499 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata; 5500 res = scsi_cmd->device->hostdata; 5501 5502 /* If we are currently going through reset/reload, return failed. 5503 * This will force the mid-layer to call ipr_eh_host_reset, 5504 * which will then go to sleep and wait for the reset to complete 5505 */ 5506 if (ioa_cfg->in_reset_reload || 5507 ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) 5508 return FAILED; 5509 if (!res) 5510 return FAILED; 5511 5512 /* 5513 * If we are aborting a timed out op, chances are that the timeout was caused 5514 * by a still not detected EEH error. In such cases, reading a register will 5515 * trigger the EEH recovery infrastructure. 5516 */ 5517 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg); 5518 5519 if (!ipr_is_gscsi(res)) 5520 return FAILED; 5521 5522 for_each_hrrq(hrrq, ioa_cfg) { 5523 spin_lock(&hrrq->_lock); 5524 for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) { 5525 if (ioa_cfg->ipr_cmnd_list[i]->scsi_cmd == scsi_cmd) { 5526 if (!ipr_cmnd_is_free(ioa_cfg->ipr_cmnd_list[i])) { 5527 op_found = 1; 5528 break; 5529 } 5530 } 5531 } 5532 spin_unlock(&hrrq->_lock); 5533 } 5534 5535 if (!op_found) 5536 return SUCCESS; 5537 5538 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg); 5539 ipr_cmd->ioarcb.res_handle = res->res_handle; 5540 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt; 5541 cmd_pkt->request_type = IPR_RQTYPE_IOACMD; 5542 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS; 5543 ipr_cmd->u.sdev = scsi_cmd->device; 5544 5545 scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n", 5546 scsi_cmd->cmnd[0]); 5547 ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT); 5548 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 5549 5550 /* 5551 * If the abort task timed out and we sent a bus reset, we will get 5552 * one the following responses to the abort 5553 */ 5554 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) { 5555 ioasc = 0; 5556 ipr_trace; 5557 } 5558 5559 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 5560 if (!ipr_is_naca_model(res)) 5561 res->needs_sync_complete = 1; 5562 5563 LEAVE; 5564 return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS; 5565 } 5566 5567 /** 5568 * ipr_eh_abort - Abort a single op 5569 * @scsi_cmd: scsi command struct 5570 * 5571 * Return value: 5572 * 0 if scan in progress / 1 if scan is complete 5573 **/ 5574 static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time) 5575 { 5576 unsigned long lock_flags; 5577 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata; 5578 int rc = 0; 5579 5580 spin_lock_irqsave(shost->host_lock, lock_flags); 5581 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done) 5582 rc = 1; 5583 if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2)) 5584 rc = 1; 5585 spin_unlock_irqrestore(shost->host_lock, lock_flags); 5586 return rc; 5587 } 5588 5589 /** 5590 * ipr_eh_host_reset - Reset the host adapter 5591 * @scsi_cmd: scsi command struct 5592 * 5593 * Return value: 5594 * SUCCESS / FAILED 5595 **/ 5596 static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd) 5597 { 5598 unsigned long flags; 5599 int rc; 5600 struct ipr_ioa_cfg *ioa_cfg; 5601 5602 ENTER; 5603 5604 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata; 5605 5606 spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags); 5607 rc = ipr_cancel_op(scsi_cmd); 5608 spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags); 5609 5610 if (rc == SUCCESS) 5611 rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun); 5612 LEAVE; 5613 return rc; 5614 } 5615 5616 /** 5617 * ipr_handle_other_interrupt - Handle "other" interrupts 5618 * @ioa_cfg: ioa config struct 5619 * @int_reg: interrupt register 5620 * 5621 * Return value: 5622 * IRQ_NONE / IRQ_HANDLED 5623 **/ 5624 static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg, 5625 u32 int_reg) 5626 { 5627 irqreturn_t rc = IRQ_HANDLED; 5628 u32 int_mask_reg; 5629 5630 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32); 5631 int_reg &= ~int_mask_reg; 5632 5633 /* If an interrupt on the adapter did not occur, ignore it. 5634 * Or in the case of SIS 64, check for a stage change interrupt. 5635 */ 5636 if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) { 5637 if (ioa_cfg->sis64) { 5638 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 5639 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg; 5640 if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) { 5641 5642 /* clear stage change */ 5643 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg); 5644 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg; 5645 list_del(&ioa_cfg->reset_cmd->queue); 5646 del_timer(&ioa_cfg->reset_cmd->timer); 5647 ipr_reset_ioa_job(ioa_cfg->reset_cmd); 5648 return IRQ_HANDLED; 5649 } 5650 } 5651 5652 return IRQ_NONE; 5653 } 5654 5655 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) { 5656 /* Mask the interrupt */ 5657 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg); 5658 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg); 5659 5660 list_del(&ioa_cfg->reset_cmd->queue); 5661 del_timer(&ioa_cfg->reset_cmd->timer); 5662 ipr_reset_ioa_job(ioa_cfg->reset_cmd); 5663 } else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) { 5664 if (ioa_cfg->clear_isr) { 5665 if (ipr_debug && printk_ratelimit()) 5666 dev_err(&ioa_cfg->pdev->dev, 5667 "Spurious interrupt detected. 0x%08X\n", int_reg); 5668 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32); 5669 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32); 5670 return IRQ_NONE; 5671 } 5672 } else { 5673 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED) 5674 ioa_cfg->ioa_unit_checked = 1; 5675 else if (int_reg & IPR_PCII_NO_HOST_RRQ) 5676 dev_err(&ioa_cfg->pdev->dev, 5677 "No Host RRQ. 0x%08X\n", int_reg); 5678 else 5679 dev_err(&ioa_cfg->pdev->dev, 5680 "Permanent IOA failure. 0x%08X\n", int_reg); 5681 5682 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state) 5683 ioa_cfg->sdt_state = GET_DUMP; 5684 5685 ipr_mask_and_clear_interrupts(ioa_cfg, ~0); 5686 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 5687 } 5688 5689 return rc; 5690 } 5691 5692 /** 5693 * ipr_isr_eh - Interrupt service routine error handler 5694 * @ioa_cfg: ioa config struct 5695 * @msg: message to log 5696 * 5697 * Return value: 5698 * none 5699 **/ 5700 static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number) 5701 { 5702 ioa_cfg->errors_logged++; 5703 dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number); 5704 5705 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state) 5706 ioa_cfg->sdt_state = GET_DUMP; 5707 5708 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 5709 } 5710 5711 static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget, 5712 struct list_head *doneq) 5713 { 5714 u32 ioasc; 5715 u16 cmd_index; 5716 struct ipr_cmnd *ipr_cmd; 5717 struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg; 5718 int num_hrrq = 0; 5719 5720 /* If interrupts are disabled, ignore the interrupt */ 5721 if (!hrr_queue->allow_interrupts) 5722 return 0; 5723 5724 while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) == 5725 hrr_queue->toggle_bit) { 5726 5727 cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) & 5728 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >> 5729 IPR_HRRQ_REQ_RESP_HANDLE_SHIFT; 5730 5731 if (unlikely(cmd_index > hrr_queue->max_cmd_id || 5732 cmd_index < hrr_queue->min_cmd_id)) { 5733 ipr_isr_eh(ioa_cfg, 5734 "Invalid response handle from IOA: ", 5735 cmd_index); 5736 break; 5737 } 5738 5739 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index]; 5740 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 5741 5742 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc); 5743 5744 list_move_tail(&ipr_cmd->queue, doneq); 5745 5746 if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) { 5747 hrr_queue->hrrq_curr++; 5748 } else { 5749 hrr_queue->hrrq_curr = hrr_queue->hrrq_start; 5750 hrr_queue->toggle_bit ^= 1u; 5751 } 5752 num_hrrq++; 5753 if (budget > 0 && num_hrrq >= budget) 5754 break; 5755 } 5756 5757 return num_hrrq; 5758 } 5759 5760 static int ipr_iopoll(struct irq_poll *iop, int budget) 5761 { 5762 struct ipr_ioa_cfg *ioa_cfg; 5763 struct ipr_hrr_queue *hrrq; 5764 struct ipr_cmnd *ipr_cmd, *temp; 5765 unsigned long hrrq_flags; 5766 int completed_ops; 5767 LIST_HEAD(doneq); 5768 5769 hrrq = container_of(iop, struct ipr_hrr_queue, iopoll); 5770 ioa_cfg = hrrq->ioa_cfg; 5771 5772 spin_lock_irqsave(hrrq->lock, hrrq_flags); 5773 completed_ops = ipr_process_hrrq(hrrq, budget, &doneq); 5774 5775 if (completed_ops < budget) 5776 irq_poll_complete(iop); 5777 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5778 5779 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) { 5780 list_del(&ipr_cmd->queue); 5781 del_timer(&ipr_cmd->timer); 5782 ipr_cmd->fast_done(ipr_cmd); 5783 } 5784 5785 return completed_ops; 5786 } 5787 5788 /** 5789 * ipr_isr - Interrupt service routine 5790 * @irq: irq number 5791 * @devp: pointer to ioa config struct 5792 * 5793 * Return value: 5794 * IRQ_NONE / IRQ_HANDLED 5795 **/ 5796 static irqreturn_t ipr_isr(int irq, void *devp) 5797 { 5798 struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp; 5799 struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg; 5800 unsigned long hrrq_flags = 0; 5801 u32 int_reg = 0; 5802 int num_hrrq = 0; 5803 int irq_none = 0; 5804 struct ipr_cmnd *ipr_cmd, *temp; 5805 irqreturn_t rc = IRQ_NONE; 5806 LIST_HEAD(doneq); 5807 5808 spin_lock_irqsave(hrrq->lock, hrrq_flags); 5809 /* If interrupts are disabled, ignore the interrupt */ 5810 if (!hrrq->allow_interrupts) { 5811 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5812 return IRQ_NONE; 5813 } 5814 5815 while (1) { 5816 if (ipr_process_hrrq(hrrq, -1, &doneq)) { 5817 rc = IRQ_HANDLED; 5818 5819 if (!ioa_cfg->clear_isr) 5820 break; 5821 5822 /* Clear the PCI interrupt */ 5823 num_hrrq = 0; 5824 do { 5825 writel(IPR_PCII_HRRQ_UPDATED, 5826 ioa_cfg->regs.clr_interrupt_reg32); 5827 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32); 5828 } while (int_reg & IPR_PCII_HRRQ_UPDATED && 5829 num_hrrq++ < IPR_MAX_HRRQ_RETRIES); 5830 5831 } else if (rc == IRQ_NONE && irq_none == 0) { 5832 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32); 5833 irq_none++; 5834 } else if (num_hrrq == IPR_MAX_HRRQ_RETRIES && 5835 int_reg & IPR_PCII_HRRQ_UPDATED) { 5836 ipr_isr_eh(ioa_cfg, 5837 "Error clearing HRRQ: ", num_hrrq); 5838 rc = IRQ_HANDLED; 5839 break; 5840 } else 5841 break; 5842 } 5843 5844 if (unlikely(rc == IRQ_NONE)) 5845 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg); 5846 5847 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5848 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) { 5849 list_del(&ipr_cmd->queue); 5850 del_timer(&ipr_cmd->timer); 5851 ipr_cmd->fast_done(ipr_cmd); 5852 } 5853 return rc; 5854 } 5855 5856 /** 5857 * ipr_isr_mhrrq - Interrupt service routine 5858 * @irq: irq number 5859 * @devp: pointer to ioa config struct 5860 * 5861 * Return value: 5862 * IRQ_NONE / IRQ_HANDLED 5863 **/ 5864 static irqreturn_t ipr_isr_mhrrq(int irq, void *devp) 5865 { 5866 struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp; 5867 struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg; 5868 unsigned long hrrq_flags = 0; 5869 struct ipr_cmnd *ipr_cmd, *temp; 5870 irqreturn_t rc = IRQ_NONE; 5871 LIST_HEAD(doneq); 5872 5873 spin_lock_irqsave(hrrq->lock, hrrq_flags); 5874 5875 /* If interrupts are disabled, ignore the interrupt */ 5876 if (!hrrq->allow_interrupts) { 5877 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5878 return IRQ_NONE; 5879 } 5880 5881 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) { 5882 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) == 5883 hrrq->toggle_bit) { 5884 irq_poll_sched(&hrrq->iopoll); 5885 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5886 return IRQ_HANDLED; 5887 } 5888 } else { 5889 if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) == 5890 hrrq->toggle_bit) 5891 5892 if (ipr_process_hrrq(hrrq, -1, &doneq)) 5893 rc = IRQ_HANDLED; 5894 } 5895 5896 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 5897 5898 list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) { 5899 list_del(&ipr_cmd->queue); 5900 del_timer(&ipr_cmd->timer); 5901 ipr_cmd->fast_done(ipr_cmd); 5902 } 5903 return rc; 5904 } 5905 5906 /** 5907 * ipr_build_ioadl64 - Build a scatter/gather list and map the buffer 5908 * @ioa_cfg: ioa config struct 5909 * @ipr_cmd: ipr command struct 5910 * 5911 * Return value: 5912 * 0 on success / -1 on failure 5913 **/ 5914 static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg, 5915 struct ipr_cmnd *ipr_cmd) 5916 { 5917 int i, nseg; 5918 struct scatterlist *sg; 5919 u32 length; 5920 u32 ioadl_flags = 0; 5921 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 5922 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 5923 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64; 5924 5925 length = scsi_bufflen(scsi_cmd); 5926 if (!length) 5927 return 0; 5928 5929 nseg = scsi_dma_map(scsi_cmd); 5930 if (nseg < 0) { 5931 if (printk_ratelimit()) 5932 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n"); 5933 return -1; 5934 } 5935 5936 ipr_cmd->dma_use_sg = nseg; 5937 5938 ioarcb->data_transfer_length = cpu_to_be32(length); 5939 ioarcb->ioadl_len = 5940 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); 5941 5942 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) { 5943 ioadl_flags = IPR_IOADL_FLAGS_WRITE; 5944 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 5945 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) 5946 ioadl_flags = IPR_IOADL_FLAGS_READ; 5947 5948 scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) { 5949 ioadl64[i].flags = cpu_to_be32(ioadl_flags); 5950 ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg)); 5951 ioadl64[i].address = cpu_to_be64(sg_dma_address(sg)); 5952 } 5953 5954 ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); 5955 return 0; 5956 } 5957 5958 /** 5959 * ipr_build_ioadl - Build a scatter/gather list and map the buffer 5960 * @ioa_cfg: ioa config struct 5961 * @ipr_cmd: ipr command struct 5962 * 5963 * Return value: 5964 * 0 on success / -1 on failure 5965 **/ 5966 static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg, 5967 struct ipr_cmnd *ipr_cmd) 5968 { 5969 int i, nseg; 5970 struct scatterlist *sg; 5971 u32 length; 5972 u32 ioadl_flags = 0; 5973 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 5974 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 5975 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl; 5976 5977 length = scsi_bufflen(scsi_cmd); 5978 if (!length) 5979 return 0; 5980 5981 nseg = scsi_dma_map(scsi_cmd); 5982 if (nseg < 0) { 5983 dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n"); 5984 return -1; 5985 } 5986 5987 ipr_cmd->dma_use_sg = nseg; 5988 5989 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) { 5990 ioadl_flags = IPR_IOADL_FLAGS_WRITE; 5991 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 5992 ioarcb->data_transfer_length = cpu_to_be32(length); 5993 ioarcb->ioadl_len = 5994 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); 5995 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) { 5996 ioadl_flags = IPR_IOADL_FLAGS_READ; 5997 ioarcb->read_data_transfer_length = cpu_to_be32(length); 5998 ioarcb->read_ioadl_len = 5999 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); 6000 } 6001 6002 if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) { 6003 ioadl = ioarcb->u.add_data.u.ioadl; 6004 ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) + 6005 offsetof(struct ipr_ioarcb, u.add_data)); 6006 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr; 6007 } 6008 6009 scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) { 6010 ioadl[i].flags_and_data_len = 6011 cpu_to_be32(ioadl_flags | sg_dma_len(sg)); 6012 ioadl[i].address = cpu_to_be32(sg_dma_address(sg)); 6013 } 6014 6015 ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); 6016 return 0; 6017 } 6018 6019 /** 6020 * __ipr_erp_done - Process completion of ERP for a device 6021 * @ipr_cmd: ipr command struct 6022 * 6023 * This function copies the sense buffer into the scsi_cmd 6024 * struct and pushes the scsi_done function. 6025 * 6026 * Return value: 6027 * nothing 6028 **/ 6029 static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd) 6030 { 6031 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 6032 struct ipr_resource_entry *res = scsi_cmd->device->hostdata; 6033 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 6034 6035 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) { 6036 scsi_cmd->result |= (DID_ERROR << 16); 6037 scmd_printk(KERN_ERR, scsi_cmd, 6038 "Request Sense failed with IOASC: 0x%08X\n", ioasc); 6039 } else { 6040 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer, 6041 SCSI_SENSE_BUFFERSIZE); 6042 } 6043 6044 if (res) { 6045 if (!ipr_is_naca_model(res)) 6046 res->needs_sync_complete = 1; 6047 res->in_erp = 0; 6048 } 6049 scsi_dma_unmap(ipr_cmd->scsi_cmd); 6050 scsi_cmd->scsi_done(scsi_cmd); 6051 if (ipr_cmd->eh_comp) 6052 complete(ipr_cmd->eh_comp); 6053 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 6054 } 6055 6056 /** 6057 * ipr_erp_done - Process completion of ERP for a device 6058 * @ipr_cmd: ipr command struct 6059 * 6060 * This function copies the sense buffer into the scsi_cmd 6061 * struct and pushes the scsi_done function. 6062 * 6063 * Return value: 6064 * nothing 6065 **/ 6066 static void ipr_erp_done(struct ipr_cmnd *ipr_cmd) 6067 { 6068 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq; 6069 unsigned long hrrq_flags; 6070 6071 spin_lock_irqsave(&hrrq->_lock, hrrq_flags); 6072 __ipr_erp_done(ipr_cmd); 6073 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags); 6074 } 6075 6076 /** 6077 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP 6078 * @ipr_cmd: ipr command struct 6079 * 6080 * Return value: 6081 * none 6082 **/ 6083 static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd) 6084 { 6085 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 6086 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa; 6087 dma_addr_t dma_addr = ipr_cmd->dma_addr; 6088 6089 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt)); 6090 ioarcb->data_transfer_length = 0; 6091 ioarcb->read_data_transfer_length = 0; 6092 ioarcb->ioadl_len = 0; 6093 ioarcb->read_ioadl_len = 0; 6094 ioasa->hdr.ioasc = 0; 6095 ioasa->hdr.residual_data_len = 0; 6096 6097 if (ipr_cmd->ioa_cfg->sis64) 6098 ioarcb->u.sis64_addr_data.data_ioadl_addr = 6099 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64)); 6100 else { 6101 ioarcb->write_ioadl_addr = 6102 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl)); 6103 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr; 6104 } 6105 } 6106 6107 /** 6108 * __ipr_erp_request_sense - Send request sense to a device 6109 * @ipr_cmd: ipr command struct 6110 * 6111 * This function sends a request sense to a device as a result 6112 * of a check condition. 6113 * 6114 * Return value: 6115 * nothing 6116 **/ 6117 static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd) 6118 { 6119 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt; 6120 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 6121 6122 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) { 6123 __ipr_erp_done(ipr_cmd); 6124 return; 6125 } 6126 6127 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd); 6128 6129 cmd_pkt->request_type = IPR_RQTYPE_SCSICDB; 6130 cmd_pkt->cdb[0] = REQUEST_SENSE; 6131 cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE; 6132 cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE; 6133 cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK; 6134 cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ); 6135 6136 ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma, 6137 SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST); 6138 6139 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout, 6140 IPR_REQUEST_SENSE_TIMEOUT * 2); 6141 } 6142 6143 /** 6144 * ipr_erp_request_sense - Send request sense to a device 6145 * @ipr_cmd: ipr command struct 6146 * 6147 * This function sends a request sense to a device as a result 6148 * of a check condition. 6149 * 6150 * Return value: 6151 * nothing 6152 **/ 6153 static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd) 6154 { 6155 struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq; 6156 unsigned long hrrq_flags; 6157 6158 spin_lock_irqsave(&hrrq->_lock, hrrq_flags); 6159 __ipr_erp_request_sense(ipr_cmd); 6160 spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags); 6161 } 6162 6163 /** 6164 * ipr_erp_cancel_all - Send cancel all to a device 6165 * @ipr_cmd: ipr command struct 6166 * 6167 * This function sends a cancel all to a device to clear the 6168 * queue. If we are running TCQ on the device, QERR is set to 1, 6169 * which means all outstanding ops have been dropped on the floor. 6170 * Cancel all will return them to us. 6171 * 6172 * Return value: 6173 * nothing 6174 **/ 6175 static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd) 6176 { 6177 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 6178 struct ipr_resource_entry *res = scsi_cmd->device->hostdata; 6179 struct ipr_cmd_pkt *cmd_pkt; 6180 6181 res->in_erp = 1; 6182 6183 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd); 6184 6185 if (!scsi_cmd->device->simple_tags) { 6186 __ipr_erp_request_sense(ipr_cmd); 6187 return; 6188 } 6189 6190 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt; 6191 cmd_pkt->request_type = IPR_RQTYPE_IOACMD; 6192 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS; 6193 6194 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout, 6195 IPR_CANCEL_ALL_TIMEOUT); 6196 } 6197 6198 /** 6199 * ipr_dump_ioasa - Dump contents of IOASA 6200 * @ioa_cfg: ioa config struct 6201 * @ipr_cmd: ipr command struct 6202 * @res: resource entry struct 6203 * 6204 * This function is invoked by the interrupt handler when ops 6205 * fail. It will log the IOASA if appropriate. Only called 6206 * for GPDD ops. 6207 * 6208 * Return value: 6209 * none 6210 **/ 6211 static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg, 6212 struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res) 6213 { 6214 int i; 6215 u16 data_len; 6216 u32 ioasc, fd_ioasc; 6217 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa; 6218 __be32 *ioasa_data = (__be32 *)ioasa; 6219 int error_index; 6220 6221 ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK; 6222 fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK; 6223 6224 if (0 == ioasc) 6225 return; 6226 6227 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL) 6228 return; 6229 6230 if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc) 6231 error_index = ipr_get_error(fd_ioasc); 6232 else 6233 error_index = ipr_get_error(ioasc); 6234 6235 if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) { 6236 /* Don't log an error if the IOA already logged one */ 6237 if (ioasa->hdr.ilid != 0) 6238 return; 6239 6240 if (!ipr_is_gscsi(res)) 6241 return; 6242 6243 if (ipr_error_table[error_index].log_ioasa == 0) 6244 return; 6245 } 6246 6247 ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error); 6248 6249 data_len = be16_to_cpu(ioasa->hdr.ret_stat_len); 6250 if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len) 6251 data_len = sizeof(struct ipr_ioasa64); 6252 else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len) 6253 data_len = sizeof(struct ipr_ioasa); 6254 6255 ipr_err("IOASA Dump:\n"); 6256 6257 for (i = 0; i < data_len / 4; i += 4) { 6258 ipr_err("%08X: %08X %08X %08X %08X\n", i*4, 6259 be32_to_cpu(ioasa_data[i]), 6260 be32_to_cpu(ioasa_data[i+1]), 6261 be32_to_cpu(ioasa_data[i+2]), 6262 be32_to_cpu(ioasa_data[i+3])); 6263 } 6264 } 6265 6266 /** 6267 * ipr_gen_sense - Generate SCSI sense data from an IOASA 6268 * @ioasa: IOASA 6269 * @sense_buf: sense data buffer 6270 * 6271 * Return value: 6272 * none 6273 **/ 6274 static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd) 6275 { 6276 u32 failing_lba; 6277 u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer; 6278 struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata; 6279 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa; 6280 u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc); 6281 6282 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE); 6283 6284 if (ioasc >= IPR_FIRST_DRIVER_IOASC) 6285 return; 6286 6287 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION; 6288 6289 if (ipr_is_vset_device(res) && 6290 ioasc == IPR_IOASC_MED_DO_NOT_REALLOC && 6291 ioasa->u.vset.failing_lba_hi != 0) { 6292 sense_buf[0] = 0x72; 6293 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc); 6294 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc); 6295 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc); 6296 6297 sense_buf[7] = 12; 6298 sense_buf[8] = 0; 6299 sense_buf[9] = 0x0A; 6300 sense_buf[10] = 0x80; 6301 6302 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi); 6303 6304 sense_buf[12] = (failing_lba & 0xff000000) >> 24; 6305 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16; 6306 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8; 6307 sense_buf[15] = failing_lba & 0x000000ff; 6308 6309 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo); 6310 6311 sense_buf[16] = (failing_lba & 0xff000000) >> 24; 6312 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16; 6313 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8; 6314 sense_buf[19] = failing_lba & 0x000000ff; 6315 } else { 6316 sense_buf[0] = 0x70; 6317 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc); 6318 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc); 6319 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc); 6320 6321 /* Illegal request */ 6322 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) && 6323 (be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) { 6324 sense_buf[7] = 10; /* additional length */ 6325 6326 /* IOARCB was in error */ 6327 if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24) 6328 sense_buf[15] = 0xC0; 6329 else /* Parameter data was invalid */ 6330 sense_buf[15] = 0x80; 6331 6332 sense_buf[16] = 6333 ((IPR_FIELD_POINTER_MASK & 6334 be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff; 6335 sense_buf[17] = 6336 (IPR_FIELD_POINTER_MASK & 6337 be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff; 6338 } else { 6339 if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) { 6340 if (ipr_is_vset_device(res)) 6341 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo); 6342 else 6343 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba); 6344 6345 sense_buf[0] |= 0x80; /* Or in the Valid bit */ 6346 sense_buf[3] = (failing_lba & 0xff000000) >> 24; 6347 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16; 6348 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8; 6349 sense_buf[6] = failing_lba & 0x000000ff; 6350 } 6351 6352 sense_buf[7] = 6; /* additional length */ 6353 } 6354 } 6355 } 6356 6357 /** 6358 * ipr_get_autosense - Copy autosense data to sense buffer 6359 * @ipr_cmd: ipr command struct 6360 * 6361 * This function copies the autosense buffer to the buffer 6362 * in the scsi_cmd, if there is autosense available. 6363 * 6364 * Return value: 6365 * 1 if autosense was available / 0 if not 6366 **/ 6367 static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd) 6368 { 6369 struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa; 6370 struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64; 6371 6372 if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0) 6373 return 0; 6374 6375 if (ipr_cmd->ioa_cfg->sis64) 6376 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data, 6377 min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len), 6378 SCSI_SENSE_BUFFERSIZE)); 6379 else 6380 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data, 6381 min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len), 6382 SCSI_SENSE_BUFFERSIZE)); 6383 return 1; 6384 } 6385 6386 /** 6387 * ipr_erp_start - Process an error response for a SCSI op 6388 * @ioa_cfg: ioa config struct 6389 * @ipr_cmd: ipr command struct 6390 * 6391 * This function determines whether or not to initiate ERP 6392 * on the affected device. 6393 * 6394 * Return value: 6395 * nothing 6396 **/ 6397 static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg, 6398 struct ipr_cmnd *ipr_cmd) 6399 { 6400 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 6401 struct ipr_resource_entry *res = scsi_cmd->device->hostdata; 6402 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 6403 u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK; 6404 6405 if (!res) { 6406 __ipr_scsi_eh_done(ipr_cmd); 6407 return; 6408 } 6409 6410 if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS) 6411 ipr_gen_sense(ipr_cmd); 6412 6413 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res); 6414 6415 switch (masked_ioasc) { 6416 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST: 6417 if (ipr_is_naca_model(res)) 6418 scsi_cmd->result |= (DID_ABORT << 16); 6419 else 6420 scsi_cmd->result |= (DID_IMM_RETRY << 16); 6421 break; 6422 case IPR_IOASC_IR_RESOURCE_HANDLE: 6423 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA: 6424 scsi_cmd->result |= (DID_NO_CONNECT << 16); 6425 break; 6426 case IPR_IOASC_HW_SEL_TIMEOUT: 6427 scsi_cmd->result |= (DID_NO_CONNECT << 16); 6428 if (!ipr_is_naca_model(res)) 6429 res->needs_sync_complete = 1; 6430 break; 6431 case IPR_IOASC_SYNC_REQUIRED: 6432 if (!res->in_erp) 6433 res->needs_sync_complete = 1; 6434 scsi_cmd->result |= (DID_IMM_RETRY << 16); 6435 break; 6436 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */ 6437 case IPR_IOASA_IR_DUAL_IOA_DISABLED: 6438 /* 6439 * exception: do not set DID_PASSTHROUGH on CHECK CONDITION 6440 * so SCSI mid-layer and upper layers handle it accordingly. 6441 */ 6442 if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION) 6443 scsi_cmd->result |= (DID_PASSTHROUGH << 16); 6444 break; 6445 case IPR_IOASC_BUS_WAS_RESET: 6446 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER: 6447 /* 6448 * Report the bus reset and ask for a retry. The device 6449 * will give CC/UA the next command. 6450 */ 6451 if (!res->resetting_device) 6452 scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel); 6453 scsi_cmd->result |= (DID_ERROR << 16); 6454 if (!ipr_is_naca_model(res)) 6455 res->needs_sync_complete = 1; 6456 break; 6457 case IPR_IOASC_HW_DEV_BUS_STATUS: 6458 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc); 6459 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) { 6460 if (!ipr_get_autosense(ipr_cmd)) { 6461 if (!ipr_is_naca_model(res)) { 6462 ipr_erp_cancel_all(ipr_cmd); 6463 return; 6464 } 6465 } 6466 } 6467 if (!ipr_is_naca_model(res)) 6468 res->needs_sync_complete = 1; 6469 break; 6470 case IPR_IOASC_NR_INIT_CMD_REQUIRED: 6471 break; 6472 case IPR_IOASC_IR_NON_OPTIMIZED: 6473 if (res->raw_mode) { 6474 res->raw_mode = 0; 6475 scsi_cmd->result |= (DID_IMM_RETRY << 16); 6476 } else 6477 scsi_cmd->result |= (DID_ERROR << 16); 6478 break; 6479 default: 6480 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR) 6481 scsi_cmd->result |= (DID_ERROR << 16); 6482 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res)) 6483 res->needs_sync_complete = 1; 6484 break; 6485 } 6486 6487 scsi_dma_unmap(ipr_cmd->scsi_cmd); 6488 scsi_cmd->scsi_done(scsi_cmd); 6489 if (ipr_cmd->eh_comp) 6490 complete(ipr_cmd->eh_comp); 6491 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 6492 } 6493 6494 /** 6495 * ipr_scsi_done - mid-layer done function 6496 * @ipr_cmd: ipr command struct 6497 * 6498 * This function is invoked by the interrupt handler for 6499 * ops generated by the SCSI mid-layer 6500 * 6501 * Return value: 6502 * none 6503 **/ 6504 static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd) 6505 { 6506 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 6507 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd; 6508 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 6509 unsigned long lock_flags; 6510 6511 scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len)); 6512 6513 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) { 6514 scsi_dma_unmap(scsi_cmd); 6515 6516 spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags); 6517 scsi_cmd->scsi_done(scsi_cmd); 6518 if (ipr_cmd->eh_comp) 6519 complete(ipr_cmd->eh_comp); 6520 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 6521 spin_unlock_irqrestore(ipr_cmd->hrrq->lock, lock_flags); 6522 } else { 6523 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 6524 spin_lock(&ipr_cmd->hrrq->_lock); 6525 ipr_erp_start(ioa_cfg, ipr_cmd); 6526 spin_unlock(&ipr_cmd->hrrq->_lock); 6527 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 6528 } 6529 } 6530 6531 /** 6532 * ipr_queuecommand - Queue a mid-layer request 6533 * @shost: scsi host struct 6534 * @scsi_cmd: scsi command struct 6535 * 6536 * This function queues a request generated by the mid-layer. 6537 * 6538 * Return value: 6539 * 0 on success 6540 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy 6541 * SCSI_MLQUEUE_HOST_BUSY if host is busy 6542 **/ 6543 static int ipr_queuecommand(struct Scsi_Host *shost, 6544 struct scsi_cmnd *scsi_cmd) 6545 { 6546 struct ipr_ioa_cfg *ioa_cfg; 6547 struct ipr_resource_entry *res; 6548 struct ipr_ioarcb *ioarcb; 6549 struct ipr_cmnd *ipr_cmd; 6550 unsigned long hrrq_flags, lock_flags; 6551 int rc; 6552 struct ipr_hrr_queue *hrrq; 6553 int hrrq_id; 6554 6555 ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata; 6556 6557 scsi_cmd->result = (DID_OK << 16); 6558 res = scsi_cmd->device->hostdata; 6559 6560 if (ipr_is_gata(res) && res->sata_port) { 6561 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 6562 rc = ata_sas_queuecmd(scsi_cmd, res->sata_port->ap); 6563 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 6564 return rc; 6565 } 6566 6567 hrrq_id = ipr_get_hrrq_index(ioa_cfg); 6568 hrrq = &ioa_cfg->hrrq[hrrq_id]; 6569 6570 spin_lock_irqsave(hrrq->lock, hrrq_flags); 6571 /* 6572 * We are currently blocking all devices due to a host reset 6573 * We have told the host to stop giving us new requests, but 6574 * ERP ops don't count. FIXME 6575 */ 6576 if (unlikely(!hrrq->allow_cmds && !hrrq->ioa_is_dead && !hrrq->removing_ioa)) { 6577 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6578 return SCSI_MLQUEUE_HOST_BUSY; 6579 } 6580 6581 /* 6582 * FIXME - Create scsi_set_host_offline interface 6583 * and the ioa_is_dead check can be removed 6584 */ 6585 if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) { 6586 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6587 goto err_nodev; 6588 } 6589 6590 ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq); 6591 if (ipr_cmd == NULL) { 6592 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6593 return SCSI_MLQUEUE_HOST_BUSY; 6594 } 6595 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6596 6597 ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done); 6598 ioarcb = &ipr_cmd->ioarcb; 6599 6600 memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len); 6601 ipr_cmd->scsi_cmd = scsi_cmd; 6602 ipr_cmd->done = ipr_scsi_eh_done; 6603 6604 if (ipr_is_gscsi(res)) { 6605 if (scsi_cmd->underflow == 0) 6606 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK; 6607 6608 if (res->reset_occurred) { 6609 res->reset_occurred = 0; 6610 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST; 6611 } 6612 } 6613 6614 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) { 6615 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC; 6616 6617 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR; 6618 if (scsi_cmd->flags & SCMD_TAGGED) 6619 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK; 6620 else 6621 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK; 6622 } 6623 6624 if (scsi_cmd->cmnd[0] >= 0xC0 && 6625 (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE)) { 6626 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 6627 } 6628 if (res->raw_mode && ipr_is_af_dasd_device(res)) { 6629 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE; 6630 6631 if (scsi_cmd->underflow == 0) 6632 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK; 6633 } 6634 6635 if (ioa_cfg->sis64) 6636 rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd); 6637 else 6638 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd); 6639 6640 spin_lock_irqsave(hrrq->lock, hrrq_flags); 6641 if (unlikely(rc || (!hrrq->allow_cmds && !hrrq->ioa_is_dead))) { 6642 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q); 6643 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6644 if (!rc) 6645 scsi_dma_unmap(scsi_cmd); 6646 return SCSI_MLQUEUE_HOST_BUSY; 6647 } 6648 6649 if (unlikely(hrrq->ioa_is_dead)) { 6650 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q); 6651 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6652 scsi_dma_unmap(scsi_cmd); 6653 goto err_nodev; 6654 } 6655 6656 ioarcb->res_handle = res->res_handle; 6657 if (res->needs_sync_complete) { 6658 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE; 6659 res->needs_sync_complete = 0; 6660 } 6661 list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_pending_q); 6662 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res)); 6663 ipr_send_command(ipr_cmd); 6664 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6665 return 0; 6666 6667 err_nodev: 6668 spin_lock_irqsave(hrrq->lock, hrrq_flags); 6669 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE); 6670 scsi_cmd->result = (DID_NO_CONNECT << 16); 6671 scsi_cmd->scsi_done(scsi_cmd); 6672 spin_unlock_irqrestore(hrrq->lock, hrrq_flags); 6673 return 0; 6674 } 6675 6676 /** 6677 * ipr_ioctl - IOCTL handler 6678 * @sdev: scsi device struct 6679 * @cmd: IOCTL cmd 6680 * @arg: IOCTL arg 6681 * 6682 * Return value: 6683 * 0 on success / other on failure 6684 **/ 6685 static int ipr_ioctl(struct scsi_device *sdev, unsigned int cmd, 6686 void __user *arg) 6687 { 6688 struct ipr_resource_entry *res; 6689 6690 res = (struct ipr_resource_entry *)sdev->hostdata; 6691 if (res && ipr_is_gata(res)) { 6692 if (cmd == HDIO_GET_IDENTITY) 6693 return -ENOTTY; 6694 return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg); 6695 } 6696 6697 return -EINVAL; 6698 } 6699 6700 /** 6701 * ipr_info - Get information about the card/driver 6702 * @scsi_host: scsi host struct 6703 * 6704 * Return value: 6705 * pointer to buffer with description string 6706 **/ 6707 static const char *ipr_ioa_info(struct Scsi_Host *host) 6708 { 6709 static char buffer[512]; 6710 struct ipr_ioa_cfg *ioa_cfg; 6711 unsigned long lock_flags = 0; 6712 6713 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata; 6714 6715 spin_lock_irqsave(host->host_lock, lock_flags); 6716 sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type); 6717 spin_unlock_irqrestore(host->host_lock, lock_flags); 6718 6719 return buffer; 6720 } 6721 6722 static struct scsi_host_template driver_template = { 6723 .module = THIS_MODULE, 6724 .name = "IPR", 6725 .info = ipr_ioa_info, 6726 .ioctl = ipr_ioctl, 6727 .queuecommand = ipr_queuecommand, 6728 .eh_abort_handler = ipr_eh_abort, 6729 .eh_device_reset_handler = ipr_eh_dev_reset, 6730 .eh_host_reset_handler = ipr_eh_host_reset, 6731 .slave_alloc = ipr_slave_alloc, 6732 .slave_configure = ipr_slave_configure, 6733 .slave_destroy = ipr_slave_destroy, 6734 .scan_finished = ipr_scan_finished, 6735 .target_alloc = ipr_target_alloc, 6736 .target_destroy = ipr_target_destroy, 6737 .change_queue_depth = ipr_change_queue_depth, 6738 .bios_param = ipr_biosparam, 6739 .can_queue = IPR_MAX_COMMANDS, 6740 .this_id = -1, 6741 .sg_tablesize = IPR_MAX_SGLIST, 6742 .max_sectors = IPR_IOA_MAX_SECTORS, 6743 .cmd_per_lun = IPR_MAX_CMD_PER_LUN, 6744 .shost_attrs = ipr_ioa_attrs, 6745 .sdev_attrs = ipr_dev_attrs, 6746 .proc_name = IPR_NAME, 6747 }; 6748 6749 /** 6750 * ipr_ata_phy_reset - libata phy_reset handler 6751 * @ap: ata port to reset 6752 * 6753 **/ 6754 static void ipr_ata_phy_reset(struct ata_port *ap) 6755 { 6756 unsigned long flags; 6757 struct ipr_sata_port *sata_port = ap->private_data; 6758 struct ipr_resource_entry *res = sata_port->res; 6759 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg; 6760 int rc; 6761 6762 ENTER; 6763 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 6764 while (ioa_cfg->in_reset_reload) { 6765 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 6766 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 6767 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 6768 } 6769 6770 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) 6771 goto out_unlock; 6772 6773 rc = ipr_device_reset(ioa_cfg, res); 6774 6775 if (rc) { 6776 ap->link.device[0].class = ATA_DEV_NONE; 6777 goto out_unlock; 6778 } 6779 6780 ap->link.device[0].class = res->ata_class; 6781 if (ap->link.device[0].class == ATA_DEV_UNKNOWN) 6782 ap->link.device[0].class = ATA_DEV_NONE; 6783 6784 out_unlock: 6785 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 6786 LEAVE; 6787 } 6788 6789 /** 6790 * ipr_ata_post_internal - Cleanup after an internal command 6791 * @qc: ATA queued command 6792 * 6793 * Return value: 6794 * none 6795 **/ 6796 static void ipr_ata_post_internal(struct ata_queued_cmd *qc) 6797 { 6798 struct ipr_sata_port *sata_port = qc->ap->private_data; 6799 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg; 6800 struct ipr_cmnd *ipr_cmd; 6801 struct ipr_hrr_queue *hrrq; 6802 unsigned long flags; 6803 6804 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 6805 while (ioa_cfg->in_reset_reload) { 6806 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 6807 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 6808 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 6809 } 6810 6811 for_each_hrrq(hrrq, ioa_cfg) { 6812 spin_lock(&hrrq->_lock); 6813 list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) { 6814 if (ipr_cmd->qc == qc) { 6815 ipr_device_reset(ioa_cfg, sata_port->res); 6816 break; 6817 } 6818 } 6819 spin_unlock(&hrrq->_lock); 6820 } 6821 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 6822 } 6823 6824 /** 6825 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure 6826 * @regs: destination 6827 * @tf: source ATA taskfile 6828 * 6829 * Return value: 6830 * none 6831 **/ 6832 static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs, 6833 struct ata_taskfile *tf) 6834 { 6835 regs->feature = tf->feature; 6836 regs->nsect = tf->nsect; 6837 regs->lbal = tf->lbal; 6838 regs->lbam = tf->lbam; 6839 regs->lbah = tf->lbah; 6840 regs->device = tf->device; 6841 regs->command = tf->command; 6842 regs->hob_feature = tf->hob_feature; 6843 regs->hob_nsect = tf->hob_nsect; 6844 regs->hob_lbal = tf->hob_lbal; 6845 regs->hob_lbam = tf->hob_lbam; 6846 regs->hob_lbah = tf->hob_lbah; 6847 regs->ctl = tf->ctl; 6848 } 6849 6850 /** 6851 * ipr_sata_done - done function for SATA commands 6852 * @ipr_cmd: ipr command struct 6853 * 6854 * This function is invoked by the interrupt handler for 6855 * ops generated by the SCSI mid-layer to SATA devices 6856 * 6857 * Return value: 6858 * none 6859 **/ 6860 static void ipr_sata_done(struct ipr_cmnd *ipr_cmd) 6861 { 6862 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 6863 struct ata_queued_cmd *qc = ipr_cmd->qc; 6864 struct ipr_sata_port *sata_port = qc->ap->private_data; 6865 struct ipr_resource_entry *res = sata_port->res; 6866 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 6867 6868 spin_lock(&ipr_cmd->hrrq->_lock); 6869 if (ipr_cmd->ioa_cfg->sis64) 6870 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata, 6871 sizeof(struct ipr_ioasa_gata)); 6872 else 6873 memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata, 6874 sizeof(struct ipr_ioasa_gata)); 6875 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res); 6876 6877 if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET) 6878 scsi_report_device_reset(ioa_cfg->host, res->bus, res->target); 6879 6880 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR) 6881 qc->err_mask |= __ac_err_mask(sata_port->ioasa.status); 6882 else 6883 qc->err_mask |= ac_err_mask(sata_port->ioasa.status); 6884 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 6885 spin_unlock(&ipr_cmd->hrrq->_lock); 6886 ata_qc_complete(qc); 6887 } 6888 6889 /** 6890 * ipr_build_ata_ioadl64 - Build an ATA scatter/gather list 6891 * @ipr_cmd: ipr command struct 6892 * @qc: ATA queued command 6893 * 6894 **/ 6895 static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd, 6896 struct ata_queued_cmd *qc) 6897 { 6898 u32 ioadl_flags = 0; 6899 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 6900 struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64; 6901 struct ipr_ioadl64_desc *last_ioadl64 = NULL; 6902 int len = qc->nbytes; 6903 struct scatterlist *sg; 6904 unsigned int si; 6905 dma_addr_t dma_addr = ipr_cmd->dma_addr; 6906 6907 if (len == 0) 6908 return; 6909 6910 if (qc->dma_dir == DMA_TO_DEVICE) { 6911 ioadl_flags = IPR_IOADL_FLAGS_WRITE; 6912 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 6913 } else if (qc->dma_dir == DMA_FROM_DEVICE) 6914 ioadl_flags = IPR_IOADL_FLAGS_READ; 6915 6916 ioarcb->data_transfer_length = cpu_to_be32(len); 6917 ioarcb->ioadl_len = 6918 cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg); 6919 ioarcb->u.sis64_addr_data.data_ioadl_addr = 6920 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64)); 6921 6922 for_each_sg(qc->sg, sg, qc->n_elem, si) { 6923 ioadl64->flags = cpu_to_be32(ioadl_flags); 6924 ioadl64->data_len = cpu_to_be32(sg_dma_len(sg)); 6925 ioadl64->address = cpu_to_be64(sg_dma_address(sg)); 6926 6927 last_ioadl64 = ioadl64; 6928 ioadl64++; 6929 } 6930 6931 if (likely(last_ioadl64)) 6932 last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); 6933 } 6934 6935 /** 6936 * ipr_build_ata_ioadl - Build an ATA scatter/gather list 6937 * @ipr_cmd: ipr command struct 6938 * @qc: ATA queued command 6939 * 6940 **/ 6941 static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd, 6942 struct ata_queued_cmd *qc) 6943 { 6944 u32 ioadl_flags = 0; 6945 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 6946 struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl; 6947 struct ipr_ioadl_desc *last_ioadl = NULL; 6948 int len = qc->nbytes; 6949 struct scatterlist *sg; 6950 unsigned int si; 6951 6952 if (len == 0) 6953 return; 6954 6955 if (qc->dma_dir == DMA_TO_DEVICE) { 6956 ioadl_flags = IPR_IOADL_FLAGS_WRITE; 6957 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 6958 ioarcb->data_transfer_length = cpu_to_be32(len); 6959 ioarcb->ioadl_len = 6960 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); 6961 } else if (qc->dma_dir == DMA_FROM_DEVICE) { 6962 ioadl_flags = IPR_IOADL_FLAGS_READ; 6963 ioarcb->read_data_transfer_length = cpu_to_be32(len); 6964 ioarcb->read_ioadl_len = 6965 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg); 6966 } 6967 6968 for_each_sg(qc->sg, sg, qc->n_elem, si) { 6969 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg)); 6970 ioadl->address = cpu_to_be32(sg_dma_address(sg)); 6971 6972 last_ioadl = ioadl; 6973 ioadl++; 6974 } 6975 6976 if (likely(last_ioadl)) 6977 last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST); 6978 } 6979 6980 /** 6981 * ipr_qc_defer - Get a free ipr_cmd 6982 * @qc: queued command 6983 * 6984 * Return value: 6985 * 0 if success 6986 **/ 6987 static int ipr_qc_defer(struct ata_queued_cmd *qc) 6988 { 6989 struct ata_port *ap = qc->ap; 6990 struct ipr_sata_port *sata_port = ap->private_data; 6991 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg; 6992 struct ipr_cmnd *ipr_cmd; 6993 struct ipr_hrr_queue *hrrq; 6994 int hrrq_id; 6995 6996 hrrq_id = ipr_get_hrrq_index(ioa_cfg); 6997 hrrq = &ioa_cfg->hrrq[hrrq_id]; 6998 6999 qc->lldd_task = NULL; 7000 spin_lock(&hrrq->_lock); 7001 if (unlikely(hrrq->ioa_is_dead)) { 7002 spin_unlock(&hrrq->_lock); 7003 return 0; 7004 } 7005 7006 if (unlikely(!hrrq->allow_cmds)) { 7007 spin_unlock(&hrrq->_lock); 7008 return ATA_DEFER_LINK; 7009 } 7010 7011 ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq); 7012 if (ipr_cmd == NULL) { 7013 spin_unlock(&hrrq->_lock); 7014 return ATA_DEFER_LINK; 7015 } 7016 7017 qc->lldd_task = ipr_cmd; 7018 spin_unlock(&hrrq->_lock); 7019 return 0; 7020 } 7021 7022 /** 7023 * ipr_qc_issue - Issue a SATA qc to a device 7024 * @qc: queued command 7025 * 7026 * Return value: 7027 * 0 if success 7028 **/ 7029 static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc) 7030 { 7031 struct ata_port *ap = qc->ap; 7032 struct ipr_sata_port *sata_port = ap->private_data; 7033 struct ipr_resource_entry *res = sata_port->res; 7034 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg; 7035 struct ipr_cmnd *ipr_cmd; 7036 struct ipr_ioarcb *ioarcb; 7037 struct ipr_ioarcb_ata_regs *regs; 7038 7039 if (qc->lldd_task == NULL) 7040 ipr_qc_defer(qc); 7041 7042 ipr_cmd = qc->lldd_task; 7043 if (ipr_cmd == NULL) 7044 return AC_ERR_SYSTEM; 7045 7046 qc->lldd_task = NULL; 7047 spin_lock(&ipr_cmd->hrrq->_lock); 7048 if (unlikely(!ipr_cmd->hrrq->allow_cmds || 7049 ipr_cmd->hrrq->ioa_is_dead)) { 7050 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 7051 spin_unlock(&ipr_cmd->hrrq->_lock); 7052 return AC_ERR_SYSTEM; 7053 } 7054 7055 ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done); 7056 ioarcb = &ipr_cmd->ioarcb; 7057 7058 if (ioa_cfg->sis64) { 7059 regs = &ipr_cmd->i.ata_ioadl.regs; 7060 ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb)); 7061 } else 7062 regs = &ioarcb->u.add_data.u.regs; 7063 7064 memset(regs, 0, sizeof(*regs)); 7065 ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs)); 7066 7067 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q); 7068 ipr_cmd->qc = qc; 7069 ipr_cmd->done = ipr_sata_done; 7070 ipr_cmd->ioarcb.res_handle = res->res_handle; 7071 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU; 7072 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC; 7073 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK; 7074 ipr_cmd->dma_use_sg = qc->n_elem; 7075 7076 if (ioa_cfg->sis64) 7077 ipr_build_ata_ioadl64(ipr_cmd, qc); 7078 else 7079 ipr_build_ata_ioadl(ipr_cmd, qc); 7080 7081 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION; 7082 ipr_copy_sata_tf(regs, &qc->tf); 7083 memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN); 7084 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res)); 7085 7086 switch (qc->tf.protocol) { 7087 case ATA_PROT_NODATA: 7088 case ATA_PROT_PIO: 7089 break; 7090 7091 case ATA_PROT_DMA: 7092 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA; 7093 break; 7094 7095 case ATAPI_PROT_PIO: 7096 case ATAPI_PROT_NODATA: 7097 regs->flags |= IPR_ATA_FLAG_PACKET_CMD; 7098 break; 7099 7100 case ATAPI_PROT_DMA: 7101 regs->flags |= IPR_ATA_FLAG_PACKET_CMD; 7102 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA; 7103 break; 7104 7105 default: 7106 WARN_ON(1); 7107 spin_unlock(&ipr_cmd->hrrq->_lock); 7108 return AC_ERR_INVALID; 7109 } 7110 7111 ipr_send_command(ipr_cmd); 7112 spin_unlock(&ipr_cmd->hrrq->_lock); 7113 7114 return 0; 7115 } 7116 7117 /** 7118 * ipr_qc_fill_rtf - Read result TF 7119 * @qc: ATA queued command 7120 * 7121 * Return value: 7122 * true 7123 **/ 7124 static bool ipr_qc_fill_rtf(struct ata_queued_cmd *qc) 7125 { 7126 struct ipr_sata_port *sata_port = qc->ap->private_data; 7127 struct ipr_ioasa_gata *g = &sata_port->ioasa; 7128 struct ata_taskfile *tf = &qc->result_tf; 7129 7130 tf->feature = g->error; 7131 tf->nsect = g->nsect; 7132 tf->lbal = g->lbal; 7133 tf->lbam = g->lbam; 7134 tf->lbah = g->lbah; 7135 tf->device = g->device; 7136 tf->command = g->status; 7137 tf->hob_nsect = g->hob_nsect; 7138 tf->hob_lbal = g->hob_lbal; 7139 tf->hob_lbam = g->hob_lbam; 7140 tf->hob_lbah = g->hob_lbah; 7141 7142 return true; 7143 } 7144 7145 static struct ata_port_operations ipr_sata_ops = { 7146 .phy_reset = ipr_ata_phy_reset, 7147 .hardreset = ipr_sata_reset, 7148 .post_internal_cmd = ipr_ata_post_internal, 7149 .qc_prep = ata_noop_qc_prep, 7150 .qc_defer = ipr_qc_defer, 7151 .qc_issue = ipr_qc_issue, 7152 .qc_fill_rtf = ipr_qc_fill_rtf, 7153 .port_start = ata_sas_port_start, 7154 .port_stop = ata_sas_port_stop 7155 }; 7156 7157 static struct ata_port_info sata_port_info = { 7158 .flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA | 7159 ATA_FLAG_SAS_HOST, 7160 .pio_mask = ATA_PIO4_ONLY, 7161 .mwdma_mask = ATA_MWDMA2, 7162 .udma_mask = ATA_UDMA6, 7163 .port_ops = &ipr_sata_ops 7164 }; 7165 7166 #ifdef CONFIG_PPC_PSERIES 7167 static const u16 ipr_blocked_processors[] = { 7168 PVR_NORTHSTAR, 7169 PVR_PULSAR, 7170 PVR_POWER4, 7171 PVR_ICESTAR, 7172 PVR_SSTAR, 7173 PVR_POWER4p, 7174 PVR_630, 7175 PVR_630p 7176 }; 7177 7178 /** 7179 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware 7180 * @ioa_cfg: ioa cfg struct 7181 * 7182 * Adapters that use Gemstone revision < 3.1 do not work reliably on 7183 * certain pSeries hardware. This function determines if the given 7184 * adapter is in one of these confgurations or not. 7185 * 7186 * Return value: 7187 * 1 if adapter is not supported / 0 if adapter is supported 7188 **/ 7189 static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg) 7190 { 7191 int i; 7192 7193 if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) { 7194 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) { 7195 if (pvr_version_is(ipr_blocked_processors[i])) 7196 return 1; 7197 } 7198 } 7199 return 0; 7200 } 7201 #else 7202 #define ipr_invalid_adapter(ioa_cfg) 0 7203 #endif 7204 7205 /** 7206 * ipr_ioa_bringdown_done - IOA bring down completion. 7207 * @ipr_cmd: ipr command struct 7208 * 7209 * This function processes the completion of an adapter bring down. 7210 * It wakes any reset sleepers. 7211 * 7212 * Return value: 7213 * IPR_RC_JOB_RETURN 7214 **/ 7215 static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd) 7216 { 7217 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7218 int i; 7219 7220 ENTER; 7221 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) { 7222 ipr_trace; 7223 ioa_cfg->scsi_unblock = 1; 7224 schedule_work(&ioa_cfg->work_q); 7225 } 7226 7227 ioa_cfg->in_reset_reload = 0; 7228 ioa_cfg->reset_retries = 0; 7229 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 7230 spin_lock(&ioa_cfg->hrrq[i]._lock); 7231 ioa_cfg->hrrq[i].ioa_is_dead = 1; 7232 spin_unlock(&ioa_cfg->hrrq[i]._lock); 7233 } 7234 wmb(); 7235 7236 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 7237 wake_up_all(&ioa_cfg->reset_wait_q); 7238 LEAVE; 7239 7240 return IPR_RC_JOB_RETURN; 7241 } 7242 7243 /** 7244 * ipr_ioa_reset_done - IOA reset completion. 7245 * @ipr_cmd: ipr command struct 7246 * 7247 * This function processes the completion of an adapter reset. 7248 * It schedules any necessary mid-layer add/removes and 7249 * wakes any reset sleepers. 7250 * 7251 * Return value: 7252 * IPR_RC_JOB_RETURN 7253 **/ 7254 static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd) 7255 { 7256 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7257 struct ipr_resource_entry *res; 7258 int j; 7259 7260 ENTER; 7261 ioa_cfg->in_reset_reload = 0; 7262 for (j = 0; j < ioa_cfg->hrrq_num; j++) { 7263 spin_lock(&ioa_cfg->hrrq[j]._lock); 7264 ioa_cfg->hrrq[j].allow_cmds = 1; 7265 spin_unlock(&ioa_cfg->hrrq[j]._lock); 7266 } 7267 wmb(); 7268 ioa_cfg->reset_cmd = NULL; 7269 ioa_cfg->doorbell |= IPR_RUNTIME_RESET; 7270 7271 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) { 7272 if (res->add_to_ml || res->del_from_ml) { 7273 ipr_trace; 7274 break; 7275 } 7276 } 7277 schedule_work(&ioa_cfg->work_q); 7278 7279 for (j = 0; j < IPR_NUM_HCAMS; j++) { 7280 list_del_init(&ioa_cfg->hostrcb[j]->queue); 7281 if (j < IPR_NUM_LOG_HCAMS) 7282 ipr_send_hcam(ioa_cfg, 7283 IPR_HCAM_CDB_OP_CODE_LOG_DATA, 7284 ioa_cfg->hostrcb[j]); 7285 else 7286 ipr_send_hcam(ioa_cfg, 7287 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, 7288 ioa_cfg->hostrcb[j]); 7289 } 7290 7291 scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS); 7292 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n"); 7293 7294 ioa_cfg->reset_retries = 0; 7295 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 7296 wake_up_all(&ioa_cfg->reset_wait_q); 7297 7298 ioa_cfg->scsi_unblock = 1; 7299 schedule_work(&ioa_cfg->work_q); 7300 LEAVE; 7301 return IPR_RC_JOB_RETURN; 7302 } 7303 7304 /** 7305 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer 7306 * @supported_dev: supported device struct 7307 * @vpids: vendor product id struct 7308 * 7309 * Return value: 7310 * none 7311 **/ 7312 static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev, 7313 struct ipr_std_inq_vpids *vpids) 7314 { 7315 memset(supported_dev, 0, sizeof(struct ipr_supported_device)); 7316 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids)); 7317 supported_dev->num_records = 1; 7318 supported_dev->data_length = 7319 cpu_to_be16(sizeof(struct ipr_supported_device)); 7320 supported_dev->reserved = 0; 7321 } 7322 7323 /** 7324 * ipr_set_supported_devs - Send Set Supported Devices for a device 7325 * @ipr_cmd: ipr command struct 7326 * 7327 * This function sends a Set Supported Devices to the adapter 7328 * 7329 * Return value: 7330 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 7331 **/ 7332 static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd) 7333 { 7334 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7335 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev; 7336 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7337 struct ipr_resource_entry *res = ipr_cmd->u.res; 7338 7339 ipr_cmd->job_step = ipr_ioa_reset_done; 7340 7341 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) { 7342 if (!ipr_is_scsi_disk(res)) 7343 continue; 7344 7345 ipr_cmd->u.res = res; 7346 ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids); 7347 7348 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 7349 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 7350 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 7351 7352 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES; 7353 ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES; 7354 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff; 7355 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff; 7356 7357 ipr_init_ioadl(ipr_cmd, 7358 ioa_cfg->vpd_cbs_dma + 7359 offsetof(struct ipr_misc_cbs, supp_dev), 7360 sizeof(struct ipr_supported_device), 7361 IPR_IOADL_FLAGS_WRITE_LAST); 7362 7363 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, 7364 IPR_SET_SUP_DEVICE_TIMEOUT); 7365 7366 if (!ioa_cfg->sis64) 7367 ipr_cmd->job_step = ipr_set_supported_devs; 7368 LEAVE; 7369 return IPR_RC_JOB_RETURN; 7370 } 7371 7372 LEAVE; 7373 return IPR_RC_JOB_CONTINUE; 7374 } 7375 7376 /** 7377 * ipr_get_mode_page - Locate specified mode page 7378 * @mode_pages: mode page buffer 7379 * @page_code: page code to find 7380 * @len: minimum required length for mode page 7381 * 7382 * Return value: 7383 * pointer to mode page / NULL on failure 7384 **/ 7385 static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages, 7386 u32 page_code, u32 len) 7387 { 7388 struct ipr_mode_page_hdr *mode_hdr; 7389 u32 page_length; 7390 u32 length; 7391 7392 if (!mode_pages || (mode_pages->hdr.length == 0)) 7393 return NULL; 7394 7395 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len; 7396 mode_hdr = (struct ipr_mode_page_hdr *) 7397 (mode_pages->data + mode_pages->hdr.block_desc_len); 7398 7399 while (length) { 7400 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) { 7401 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr))) 7402 return mode_hdr; 7403 break; 7404 } else { 7405 page_length = (sizeof(struct ipr_mode_page_hdr) + 7406 mode_hdr->page_length); 7407 length -= page_length; 7408 mode_hdr = (struct ipr_mode_page_hdr *) 7409 ((unsigned long)mode_hdr + page_length); 7410 } 7411 } 7412 return NULL; 7413 } 7414 7415 /** 7416 * ipr_check_term_power - Check for term power errors 7417 * @ioa_cfg: ioa config struct 7418 * @mode_pages: IOAFP mode pages buffer 7419 * 7420 * Check the IOAFP's mode page 28 for term power errors 7421 * 7422 * Return value: 7423 * nothing 7424 **/ 7425 static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg, 7426 struct ipr_mode_pages *mode_pages) 7427 { 7428 int i; 7429 int entry_length; 7430 struct ipr_dev_bus_entry *bus; 7431 struct ipr_mode_page28 *mode_page; 7432 7433 mode_page = ipr_get_mode_page(mode_pages, 0x28, 7434 sizeof(struct ipr_mode_page28)); 7435 7436 entry_length = mode_page->entry_length; 7437 7438 bus = mode_page->bus; 7439 7440 for (i = 0; i < mode_page->num_entries; i++) { 7441 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) { 7442 dev_err(&ioa_cfg->pdev->dev, 7443 "Term power is absent on scsi bus %d\n", 7444 bus->res_addr.bus); 7445 } 7446 7447 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length); 7448 } 7449 } 7450 7451 /** 7452 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table 7453 * @ioa_cfg: ioa config struct 7454 * 7455 * Looks through the config table checking for SES devices. If 7456 * the SES device is in the SES table indicating a maximum SCSI 7457 * bus speed, the speed is limited for the bus. 7458 * 7459 * Return value: 7460 * none 7461 **/ 7462 static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg) 7463 { 7464 u32 max_xfer_rate; 7465 int i; 7466 7467 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) { 7468 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i, 7469 ioa_cfg->bus_attr[i].bus_width); 7470 7471 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate) 7472 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate; 7473 } 7474 } 7475 7476 /** 7477 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28 7478 * @ioa_cfg: ioa config struct 7479 * @mode_pages: mode page 28 buffer 7480 * 7481 * Updates mode page 28 based on driver configuration 7482 * 7483 * Return value: 7484 * none 7485 **/ 7486 static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg, 7487 struct ipr_mode_pages *mode_pages) 7488 { 7489 int i, entry_length; 7490 struct ipr_dev_bus_entry *bus; 7491 struct ipr_bus_attributes *bus_attr; 7492 struct ipr_mode_page28 *mode_page; 7493 7494 mode_page = ipr_get_mode_page(mode_pages, 0x28, 7495 sizeof(struct ipr_mode_page28)); 7496 7497 entry_length = mode_page->entry_length; 7498 7499 /* Loop for each device bus entry */ 7500 for (i = 0, bus = mode_page->bus; 7501 i < mode_page->num_entries; 7502 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) { 7503 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) { 7504 dev_err(&ioa_cfg->pdev->dev, 7505 "Invalid resource address reported: 0x%08X\n", 7506 IPR_GET_PHYS_LOC(bus->res_addr)); 7507 continue; 7508 } 7509 7510 bus_attr = &ioa_cfg->bus_attr[i]; 7511 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY; 7512 bus->bus_width = bus_attr->bus_width; 7513 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate); 7514 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK; 7515 if (bus_attr->qas_enabled) 7516 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS; 7517 else 7518 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS; 7519 } 7520 } 7521 7522 /** 7523 * ipr_build_mode_select - Build a mode select command 7524 * @ipr_cmd: ipr command struct 7525 * @res_handle: resource handle to send command to 7526 * @parm: Byte 2 of Mode Sense command 7527 * @dma_addr: DMA buffer address 7528 * @xfer_len: data transfer length 7529 * 7530 * Return value: 7531 * none 7532 **/ 7533 static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd, 7534 __be32 res_handle, u8 parm, 7535 dma_addr_t dma_addr, u8 xfer_len) 7536 { 7537 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7538 7539 ioarcb->res_handle = res_handle; 7540 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB; 7541 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ; 7542 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT; 7543 ioarcb->cmd_pkt.cdb[1] = parm; 7544 ioarcb->cmd_pkt.cdb[4] = xfer_len; 7545 7546 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST); 7547 } 7548 7549 /** 7550 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA 7551 * @ipr_cmd: ipr command struct 7552 * 7553 * This function sets up the SCSI bus attributes and sends 7554 * a Mode Select for Page 28 to activate them. 7555 * 7556 * Return value: 7557 * IPR_RC_JOB_RETURN 7558 **/ 7559 static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd) 7560 { 7561 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7562 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages; 7563 int length; 7564 7565 ENTER; 7566 ipr_scsi_bus_speed_limit(ioa_cfg); 7567 ipr_check_term_power(ioa_cfg, mode_pages); 7568 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages); 7569 length = mode_pages->hdr.length + 1; 7570 mode_pages->hdr.length = 0; 7571 7572 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11, 7573 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages), 7574 length); 7575 7576 ipr_cmd->job_step = ipr_set_supported_devs; 7577 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next, 7578 struct ipr_resource_entry, queue); 7579 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7580 7581 LEAVE; 7582 return IPR_RC_JOB_RETURN; 7583 } 7584 7585 /** 7586 * ipr_build_mode_sense - Builds a mode sense command 7587 * @ipr_cmd: ipr command struct 7588 * @res: resource entry struct 7589 * @parm: Byte 2 of mode sense command 7590 * @dma_addr: DMA address of mode sense buffer 7591 * @xfer_len: Size of DMA buffer 7592 * 7593 * Return value: 7594 * none 7595 **/ 7596 static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd, 7597 __be32 res_handle, 7598 u8 parm, dma_addr_t dma_addr, u8 xfer_len) 7599 { 7600 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7601 7602 ioarcb->res_handle = res_handle; 7603 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE; 7604 ioarcb->cmd_pkt.cdb[2] = parm; 7605 ioarcb->cmd_pkt.cdb[4] = xfer_len; 7606 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB; 7607 7608 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST); 7609 } 7610 7611 /** 7612 * ipr_reset_cmd_failed - Handle failure of IOA reset command 7613 * @ipr_cmd: ipr command struct 7614 * 7615 * This function handles the failure of an IOA bringup command. 7616 * 7617 * Return value: 7618 * IPR_RC_JOB_RETURN 7619 **/ 7620 static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd) 7621 { 7622 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7623 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 7624 7625 dev_err(&ioa_cfg->pdev->dev, 7626 "0x%02X failed with IOASC: 0x%08X\n", 7627 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc); 7628 7629 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 7630 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 7631 return IPR_RC_JOB_RETURN; 7632 } 7633 7634 /** 7635 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense 7636 * @ipr_cmd: ipr command struct 7637 * 7638 * This function handles the failure of a Mode Sense to the IOAFP. 7639 * Some adapters do not handle all mode pages. 7640 * 7641 * Return value: 7642 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 7643 **/ 7644 static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd) 7645 { 7646 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7647 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 7648 7649 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) { 7650 ipr_cmd->job_step = ipr_set_supported_devs; 7651 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next, 7652 struct ipr_resource_entry, queue); 7653 return IPR_RC_JOB_CONTINUE; 7654 } 7655 7656 return ipr_reset_cmd_failed(ipr_cmd); 7657 } 7658 7659 /** 7660 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA 7661 * @ipr_cmd: ipr command struct 7662 * 7663 * This function send a Page 28 mode sense to the IOA to 7664 * retrieve SCSI bus attributes. 7665 * 7666 * Return value: 7667 * IPR_RC_JOB_RETURN 7668 **/ 7669 static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd) 7670 { 7671 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7672 7673 ENTER; 7674 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 7675 0x28, ioa_cfg->vpd_cbs_dma + 7676 offsetof(struct ipr_misc_cbs, mode_pages), 7677 sizeof(struct ipr_mode_pages)); 7678 7679 ipr_cmd->job_step = ipr_ioafp_mode_select_page28; 7680 ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed; 7681 7682 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7683 7684 LEAVE; 7685 return IPR_RC_JOB_RETURN; 7686 } 7687 7688 /** 7689 * ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA 7690 * @ipr_cmd: ipr command struct 7691 * 7692 * This function enables dual IOA RAID support if possible. 7693 * 7694 * Return value: 7695 * IPR_RC_JOB_RETURN 7696 **/ 7697 static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd) 7698 { 7699 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7700 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages; 7701 struct ipr_mode_page24 *mode_page; 7702 int length; 7703 7704 ENTER; 7705 mode_page = ipr_get_mode_page(mode_pages, 0x24, 7706 sizeof(struct ipr_mode_page24)); 7707 7708 if (mode_page) 7709 mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF; 7710 7711 length = mode_pages->hdr.length + 1; 7712 mode_pages->hdr.length = 0; 7713 7714 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11, 7715 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages), 7716 length); 7717 7718 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28; 7719 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7720 7721 LEAVE; 7722 return IPR_RC_JOB_RETURN; 7723 } 7724 7725 /** 7726 * ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense 7727 * @ipr_cmd: ipr command struct 7728 * 7729 * This function handles the failure of a Mode Sense to the IOAFP. 7730 * Some adapters do not handle all mode pages. 7731 * 7732 * Return value: 7733 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 7734 **/ 7735 static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd) 7736 { 7737 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 7738 7739 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) { 7740 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28; 7741 return IPR_RC_JOB_CONTINUE; 7742 } 7743 7744 return ipr_reset_cmd_failed(ipr_cmd); 7745 } 7746 7747 /** 7748 * ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA 7749 * @ipr_cmd: ipr command struct 7750 * 7751 * This function send a mode sense to the IOA to retrieve 7752 * the IOA Advanced Function Control mode page. 7753 * 7754 * Return value: 7755 * IPR_RC_JOB_RETURN 7756 **/ 7757 static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd) 7758 { 7759 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7760 7761 ENTER; 7762 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 7763 0x24, ioa_cfg->vpd_cbs_dma + 7764 offsetof(struct ipr_misc_cbs, mode_pages), 7765 sizeof(struct ipr_mode_pages)); 7766 7767 ipr_cmd->job_step = ipr_ioafp_mode_select_page24; 7768 ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed; 7769 7770 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7771 7772 LEAVE; 7773 return IPR_RC_JOB_RETURN; 7774 } 7775 7776 /** 7777 * ipr_init_res_table - Initialize the resource table 7778 * @ipr_cmd: ipr command struct 7779 * 7780 * This function looks through the existing resource table, comparing 7781 * it with the config table. This function will take care of old/new 7782 * devices and schedule adding/removing them from the mid-layer 7783 * as appropriate. 7784 * 7785 * Return value: 7786 * IPR_RC_JOB_CONTINUE 7787 **/ 7788 static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd) 7789 { 7790 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7791 struct ipr_resource_entry *res, *temp; 7792 struct ipr_config_table_entry_wrapper cfgtew; 7793 int entries, found, flag, i; 7794 LIST_HEAD(old_res); 7795 7796 ENTER; 7797 if (ioa_cfg->sis64) 7798 flag = ioa_cfg->u.cfg_table64->hdr64.flags; 7799 else 7800 flag = ioa_cfg->u.cfg_table->hdr.flags; 7801 7802 if (flag & IPR_UCODE_DOWNLOAD_REQ) 7803 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n"); 7804 7805 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue) 7806 list_move_tail(&res->queue, &old_res); 7807 7808 if (ioa_cfg->sis64) 7809 entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries); 7810 else 7811 entries = ioa_cfg->u.cfg_table->hdr.num_entries; 7812 7813 for (i = 0; i < entries; i++) { 7814 if (ioa_cfg->sis64) 7815 cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i]; 7816 else 7817 cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i]; 7818 found = 0; 7819 7820 list_for_each_entry_safe(res, temp, &old_res, queue) { 7821 if (ipr_is_same_device(res, &cfgtew)) { 7822 list_move_tail(&res->queue, &ioa_cfg->used_res_q); 7823 found = 1; 7824 break; 7825 } 7826 } 7827 7828 if (!found) { 7829 if (list_empty(&ioa_cfg->free_res_q)) { 7830 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n"); 7831 break; 7832 } 7833 7834 found = 1; 7835 res = list_entry(ioa_cfg->free_res_q.next, 7836 struct ipr_resource_entry, queue); 7837 list_move_tail(&res->queue, &ioa_cfg->used_res_q); 7838 ipr_init_res_entry(res, &cfgtew); 7839 res->add_to_ml = 1; 7840 } else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))) 7841 res->sdev->allow_restart = 1; 7842 7843 if (found) 7844 ipr_update_res_entry(res, &cfgtew); 7845 } 7846 7847 list_for_each_entry_safe(res, temp, &old_res, queue) { 7848 if (res->sdev) { 7849 res->del_from_ml = 1; 7850 res->res_handle = IPR_INVALID_RES_HANDLE; 7851 list_move_tail(&res->queue, &ioa_cfg->used_res_q); 7852 } 7853 } 7854 7855 list_for_each_entry_safe(res, temp, &old_res, queue) { 7856 ipr_clear_res_target(res); 7857 list_move_tail(&res->queue, &ioa_cfg->free_res_q); 7858 } 7859 7860 if (ioa_cfg->dual_raid && ipr_dual_ioa_raid) 7861 ipr_cmd->job_step = ipr_ioafp_mode_sense_page24; 7862 else 7863 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28; 7864 7865 LEAVE; 7866 return IPR_RC_JOB_CONTINUE; 7867 } 7868 7869 /** 7870 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter. 7871 * @ipr_cmd: ipr command struct 7872 * 7873 * This function sends a Query IOA Configuration command 7874 * to the adapter to retrieve the IOA configuration table. 7875 * 7876 * Return value: 7877 * IPR_RC_JOB_RETURN 7878 **/ 7879 static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd) 7880 { 7881 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7882 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7883 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data; 7884 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap; 7885 7886 ENTER; 7887 if (cap->cap & IPR_CAP_DUAL_IOA_RAID) 7888 ioa_cfg->dual_raid = 1; 7889 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n", 7890 ucode_vpd->major_release, ucode_vpd->card_type, 7891 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]); 7892 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 7893 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 7894 7895 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG; 7896 ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff; 7897 ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff; 7898 ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff; 7899 7900 ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size, 7901 IPR_IOADL_FLAGS_READ_LAST); 7902 7903 ipr_cmd->job_step = ipr_init_res_table; 7904 7905 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7906 7907 LEAVE; 7908 return IPR_RC_JOB_RETURN; 7909 } 7910 7911 static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd) 7912 { 7913 u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 7914 7915 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) 7916 return IPR_RC_JOB_CONTINUE; 7917 7918 return ipr_reset_cmd_failed(ipr_cmd); 7919 } 7920 7921 static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd, 7922 __be32 res_handle, u8 sa_code) 7923 { 7924 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7925 7926 ioarcb->res_handle = res_handle; 7927 ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION; 7928 ioarcb->cmd_pkt.cdb[1] = sa_code; 7929 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 7930 } 7931 7932 /** 7933 * ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service 7934 * action 7935 * 7936 * Return value: 7937 * none 7938 **/ 7939 static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd) 7940 { 7941 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7942 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 7943 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data; 7944 7945 ENTER; 7946 7947 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg; 7948 7949 if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) { 7950 ipr_build_ioa_service_action(ipr_cmd, 7951 cpu_to_be32(IPR_IOA_RES_HANDLE), 7952 IPR_IOA_SA_CHANGE_CACHE_PARAMS); 7953 7954 ioarcb->cmd_pkt.cdb[2] = 0x40; 7955 7956 ipr_cmd->job_step_failed = ipr_ioa_service_action_failed; 7957 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, 7958 IPR_SET_SUP_DEVICE_TIMEOUT); 7959 7960 LEAVE; 7961 return IPR_RC_JOB_RETURN; 7962 } 7963 7964 LEAVE; 7965 return IPR_RC_JOB_CONTINUE; 7966 } 7967 7968 /** 7969 * ipr_ioafp_inquiry - Send an Inquiry to the adapter. 7970 * @ipr_cmd: ipr command struct 7971 * 7972 * This utility function sends an inquiry to the adapter. 7973 * 7974 * Return value: 7975 * none 7976 **/ 7977 static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page, 7978 dma_addr_t dma_addr, u8 xfer_len) 7979 { 7980 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 7981 7982 ENTER; 7983 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB; 7984 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 7985 7986 ioarcb->cmd_pkt.cdb[0] = INQUIRY; 7987 ioarcb->cmd_pkt.cdb[1] = flags; 7988 ioarcb->cmd_pkt.cdb[2] = page; 7989 ioarcb->cmd_pkt.cdb[4] = xfer_len; 7990 7991 ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST); 7992 7993 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT); 7994 LEAVE; 7995 } 7996 7997 /** 7998 * ipr_inquiry_page_supported - Is the given inquiry page supported 7999 * @page0: inquiry page 0 buffer 8000 * @page: page code. 8001 * 8002 * This function determines if the specified inquiry page is supported. 8003 * 8004 * Return value: 8005 * 1 if page is supported / 0 if not 8006 **/ 8007 static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page) 8008 { 8009 int i; 8010 8011 for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++) 8012 if (page0->page[i] == page) 8013 return 1; 8014 8015 return 0; 8016 } 8017 8018 /** 8019 * ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter. 8020 * @ipr_cmd: ipr command struct 8021 * 8022 * This function sends a Page 0xC4 inquiry to the adapter 8023 * to retrieve software VPD information. 8024 * 8025 * Return value: 8026 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8027 **/ 8028 static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd) 8029 { 8030 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8031 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data; 8032 struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data; 8033 8034 ENTER; 8035 ipr_cmd->job_step = ipr_ioafp_set_caching_parameters; 8036 memset(pageC4, 0, sizeof(*pageC4)); 8037 8038 if (ipr_inquiry_page_supported(page0, 0xC4)) { 8039 ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4, 8040 (ioa_cfg->vpd_cbs_dma 8041 + offsetof(struct ipr_misc_cbs, 8042 pageC4_data)), 8043 sizeof(struct ipr_inquiry_pageC4)); 8044 return IPR_RC_JOB_RETURN; 8045 } 8046 8047 LEAVE; 8048 return IPR_RC_JOB_CONTINUE; 8049 } 8050 8051 /** 8052 * ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter. 8053 * @ipr_cmd: ipr command struct 8054 * 8055 * This function sends a Page 0xD0 inquiry to the adapter 8056 * to retrieve adapter capabilities. 8057 * 8058 * Return value: 8059 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8060 **/ 8061 static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd) 8062 { 8063 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8064 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data; 8065 struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap; 8066 8067 ENTER; 8068 ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry; 8069 memset(cap, 0, sizeof(*cap)); 8070 8071 if (ipr_inquiry_page_supported(page0, 0xD0)) { 8072 ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0, 8073 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap), 8074 sizeof(struct ipr_inquiry_cap)); 8075 return IPR_RC_JOB_RETURN; 8076 } 8077 8078 LEAVE; 8079 return IPR_RC_JOB_CONTINUE; 8080 } 8081 8082 /** 8083 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter. 8084 * @ipr_cmd: ipr command struct 8085 * 8086 * This function sends a Page 3 inquiry to the adapter 8087 * to retrieve software VPD information. 8088 * 8089 * Return value: 8090 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8091 **/ 8092 static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd) 8093 { 8094 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8095 8096 ENTER; 8097 8098 ipr_cmd->job_step = ipr_ioafp_cap_inquiry; 8099 8100 ipr_ioafp_inquiry(ipr_cmd, 1, 3, 8101 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data), 8102 sizeof(struct ipr_inquiry_page3)); 8103 8104 LEAVE; 8105 return IPR_RC_JOB_RETURN; 8106 } 8107 8108 /** 8109 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter. 8110 * @ipr_cmd: ipr command struct 8111 * 8112 * This function sends a Page 0 inquiry to the adapter 8113 * to retrieve supported inquiry pages. 8114 * 8115 * Return value: 8116 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8117 **/ 8118 static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd) 8119 { 8120 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8121 char type[5]; 8122 8123 ENTER; 8124 8125 /* Grab the type out of the VPD and store it away */ 8126 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4); 8127 type[4] = '\0'; 8128 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16); 8129 8130 if (ipr_invalid_adapter(ioa_cfg)) { 8131 dev_err(&ioa_cfg->pdev->dev, 8132 "Adapter not supported in this hardware configuration.\n"); 8133 8134 if (!ipr_testmode) { 8135 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES; 8136 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 8137 list_add_tail(&ipr_cmd->queue, 8138 &ioa_cfg->hrrq->hrrq_free_q); 8139 return IPR_RC_JOB_RETURN; 8140 } 8141 } 8142 8143 ipr_cmd->job_step = ipr_ioafp_page3_inquiry; 8144 8145 ipr_ioafp_inquiry(ipr_cmd, 1, 0, 8146 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data), 8147 sizeof(struct ipr_inquiry_page0)); 8148 8149 LEAVE; 8150 return IPR_RC_JOB_RETURN; 8151 } 8152 8153 /** 8154 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter. 8155 * @ipr_cmd: ipr command struct 8156 * 8157 * This function sends a standard inquiry to the adapter. 8158 * 8159 * Return value: 8160 * IPR_RC_JOB_RETURN 8161 **/ 8162 static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd) 8163 { 8164 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8165 8166 ENTER; 8167 ipr_cmd->job_step = ipr_ioafp_page0_inquiry; 8168 8169 ipr_ioafp_inquiry(ipr_cmd, 0, 0, 8170 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd), 8171 sizeof(struct ipr_ioa_vpd)); 8172 8173 LEAVE; 8174 return IPR_RC_JOB_RETURN; 8175 } 8176 8177 /** 8178 * ipr_ioafp_identify_hrrq - Send Identify Host RRQ. 8179 * @ipr_cmd: ipr command struct 8180 * 8181 * This function send an Identify Host Request Response Queue 8182 * command to establish the HRRQ with the adapter. 8183 * 8184 * Return value: 8185 * IPR_RC_JOB_RETURN 8186 **/ 8187 static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd) 8188 { 8189 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8190 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb; 8191 struct ipr_hrr_queue *hrrq; 8192 8193 ENTER; 8194 ipr_cmd->job_step = ipr_ioafp_std_inquiry; 8195 if (ioa_cfg->identify_hrrq_index == 0) 8196 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n"); 8197 8198 if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) { 8199 hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index]; 8200 8201 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q; 8202 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 8203 8204 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 8205 if (ioa_cfg->sis64) 8206 ioarcb->cmd_pkt.cdb[1] = 0x1; 8207 8208 if (ioa_cfg->nvectors == 1) 8209 ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE; 8210 else 8211 ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE; 8212 8213 ioarcb->cmd_pkt.cdb[2] = 8214 ((u64) hrrq->host_rrq_dma >> 24) & 0xff; 8215 ioarcb->cmd_pkt.cdb[3] = 8216 ((u64) hrrq->host_rrq_dma >> 16) & 0xff; 8217 ioarcb->cmd_pkt.cdb[4] = 8218 ((u64) hrrq->host_rrq_dma >> 8) & 0xff; 8219 ioarcb->cmd_pkt.cdb[5] = 8220 ((u64) hrrq->host_rrq_dma) & 0xff; 8221 ioarcb->cmd_pkt.cdb[7] = 8222 ((sizeof(u32) * hrrq->size) >> 8) & 0xff; 8223 ioarcb->cmd_pkt.cdb[8] = 8224 (sizeof(u32) * hrrq->size) & 0xff; 8225 8226 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE) 8227 ioarcb->cmd_pkt.cdb[9] = 8228 ioa_cfg->identify_hrrq_index; 8229 8230 if (ioa_cfg->sis64) { 8231 ioarcb->cmd_pkt.cdb[10] = 8232 ((u64) hrrq->host_rrq_dma >> 56) & 0xff; 8233 ioarcb->cmd_pkt.cdb[11] = 8234 ((u64) hrrq->host_rrq_dma >> 48) & 0xff; 8235 ioarcb->cmd_pkt.cdb[12] = 8236 ((u64) hrrq->host_rrq_dma >> 40) & 0xff; 8237 ioarcb->cmd_pkt.cdb[13] = 8238 ((u64) hrrq->host_rrq_dma >> 32) & 0xff; 8239 } 8240 8241 if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE) 8242 ioarcb->cmd_pkt.cdb[14] = 8243 ioa_cfg->identify_hrrq_index; 8244 8245 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, 8246 IPR_INTERNAL_TIMEOUT); 8247 8248 if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) 8249 ipr_cmd->job_step = ipr_ioafp_identify_hrrq; 8250 8251 LEAVE; 8252 return IPR_RC_JOB_RETURN; 8253 } 8254 8255 LEAVE; 8256 return IPR_RC_JOB_CONTINUE; 8257 } 8258 8259 /** 8260 * ipr_reset_timer_done - Adapter reset timer function 8261 * @ipr_cmd: ipr command struct 8262 * 8263 * Description: This function is used in adapter reset processing 8264 * for timing events. If the reset_cmd pointer in the IOA 8265 * config struct is not this adapter's we are doing nested 8266 * resets and fail_all_ops will take care of freeing the 8267 * command block. 8268 * 8269 * Return value: 8270 * none 8271 **/ 8272 static void ipr_reset_timer_done(struct timer_list *t) 8273 { 8274 struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer); 8275 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8276 unsigned long lock_flags = 0; 8277 8278 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 8279 8280 if (ioa_cfg->reset_cmd == ipr_cmd) { 8281 list_del(&ipr_cmd->queue); 8282 ipr_cmd->done(ipr_cmd); 8283 } 8284 8285 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 8286 } 8287 8288 /** 8289 * ipr_reset_start_timer - Start a timer for adapter reset job 8290 * @ipr_cmd: ipr command struct 8291 * @timeout: timeout value 8292 * 8293 * Description: This function is used in adapter reset processing 8294 * for timing events. If the reset_cmd pointer in the IOA 8295 * config struct is not this adapter's we are doing nested 8296 * resets and fail_all_ops will take care of freeing the 8297 * command block. 8298 * 8299 * Return value: 8300 * none 8301 **/ 8302 static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd, 8303 unsigned long timeout) 8304 { 8305 8306 ENTER; 8307 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q); 8308 ipr_cmd->done = ipr_reset_ioa_job; 8309 8310 ipr_cmd->timer.expires = jiffies + timeout; 8311 ipr_cmd->timer.function = ipr_reset_timer_done; 8312 add_timer(&ipr_cmd->timer); 8313 } 8314 8315 /** 8316 * ipr_init_ioa_mem - Initialize ioa_cfg control block 8317 * @ioa_cfg: ioa cfg struct 8318 * 8319 * Return value: 8320 * nothing 8321 **/ 8322 static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg) 8323 { 8324 struct ipr_hrr_queue *hrrq; 8325 8326 for_each_hrrq(hrrq, ioa_cfg) { 8327 spin_lock(&hrrq->_lock); 8328 memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size); 8329 8330 /* Initialize Host RRQ pointers */ 8331 hrrq->hrrq_start = hrrq->host_rrq; 8332 hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1]; 8333 hrrq->hrrq_curr = hrrq->hrrq_start; 8334 hrrq->toggle_bit = 1; 8335 spin_unlock(&hrrq->_lock); 8336 } 8337 wmb(); 8338 8339 ioa_cfg->identify_hrrq_index = 0; 8340 if (ioa_cfg->hrrq_num == 1) 8341 atomic_set(&ioa_cfg->hrrq_index, 0); 8342 else 8343 atomic_set(&ioa_cfg->hrrq_index, 1); 8344 8345 /* Zero out config table */ 8346 memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size); 8347 } 8348 8349 /** 8350 * ipr_reset_next_stage - Process IPL stage change based on feedback register. 8351 * @ipr_cmd: ipr command struct 8352 * 8353 * Return value: 8354 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8355 **/ 8356 static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd) 8357 { 8358 unsigned long stage, stage_time; 8359 u32 feedback; 8360 volatile u32 int_reg; 8361 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8362 u64 maskval = 0; 8363 8364 feedback = readl(ioa_cfg->regs.init_feedback_reg); 8365 stage = feedback & IPR_IPL_INIT_STAGE_MASK; 8366 stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK; 8367 8368 ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time); 8369 8370 /* sanity check the stage_time value */ 8371 if (stage_time == 0) 8372 stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME; 8373 else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME) 8374 stage_time = IPR_IPL_INIT_MIN_STAGE_TIME; 8375 else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT) 8376 stage_time = IPR_LONG_OPERATIONAL_TIMEOUT; 8377 8378 if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) { 8379 writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg); 8380 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 8381 stage_time = ioa_cfg->transop_timeout; 8382 ipr_cmd->job_step = ipr_ioafp_identify_hrrq; 8383 } else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) { 8384 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32); 8385 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) { 8386 ipr_cmd->job_step = ipr_ioafp_identify_hrrq; 8387 maskval = IPR_PCII_IPL_STAGE_CHANGE; 8388 maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER; 8389 writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg); 8390 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 8391 return IPR_RC_JOB_CONTINUE; 8392 } 8393 } 8394 8395 ipr_cmd->timer.expires = jiffies + stage_time * HZ; 8396 ipr_cmd->timer.function = ipr_oper_timeout; 8397 ipr_cmd->done = ipr_reset_ioa_job; 8398 add_timer(&ipr_cmd->timer); 8399 8400 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q); 8401 8402 return IPR_RC_JOB_RETURN; 8403 } 8404 8405 /** 8406 * ipr_reset_enable_ioa - Enable the IOA following a reset. 8407 * @ipr_cmd: ipr command struct 8408 * 8409 * This function reinitializes some control blocks and 8410 * enables destructive diagnostics on the adapter. 8411 * 8412 * Return value: 8413 * IPR_RC_JOB_RETURN 8414 **/ 8415 static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd) 8416 { 8417 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8418 volatile u32 int_reg; 8419 volatile u64 maskval; 8420 int i; 8421 8422 ENTER; 8423 ipr_cmd->job_step = ipr_ioafp_identify_hrrq; 8424 ipr_init_ioa_mem(ioa_cfg); 8425 8426 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 8427 spin_lock(&ioa_cfg->hrrq[i]._lock); 8428 ioa_cfg->hrrq[i].allow_interrupts = 1; 8429 spin_unlock(&ioa_cfg->hrrq[i]._lock); 8430 } 8431 if (ioa_cfg->sis64) { 8432 /* Set the adapter to the correct endian mode. */ 8433 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg); 8434 int_reg = readl(ioa_cfg->regs.endian_swap_reg); 8435 } 8436 8437 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32); 8438 8439 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) { 8440 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED), 8441 ioa_cfg->regs.clr_interrupt_mask_reg32); 8442 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 8443 return IPR_RC_JOB_CONTINUE; 8444 } 8445 8446 /* Enable destructive diagnostics on IOA */ 8447 writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32); 8448 8449 if (ioa_cfg->sis64) { 8450 maskval = IPR_PCII_IPL_STAGE_CHANGE; 8451 maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS; 8452 writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg); 8453 } else 8454 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32); 8455 8456 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 8457 8458 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n"); 8459 8460 if (ioa_cfg->sis64) { 8461 ipr_cmd->job_step = ipr_reset_next_stage; 8462 return IPR_RC_JOB_CONTINUE; 8463 } 8464 8465 ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ); 8466 ipr_cmd->timer.function = ipr_oper_timeout; 8467 ipr_cmd->done = ipr_reset_ioa_job; 8468 add_timer(&ipr_cmd->timer); 8469 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q); 8470 8471 LEAVE; 8472 return IPR_RC_JOB_RETURN; 8473 } 8474 8475 /** 8476 * ipr_reset_wait_for_dump - Wait for a dump to timeout. 8477 * @ipr_cmd: ipr command struct 8478 * 8479 * This function is invoked when an adapter dump has run out 8480 * of processing time. 8481 * 8482 * Return value: 8483 * IPR_RC_JOB_CONTINUE 8484 **/ 8485 static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd) 8486 { 8487 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8488 8489 if (ioa_cfg->sdt_state == GET_DUMP) 8490 ioa_cfg->sdt_state = WAIT_FOR_DUMP; 8491 else if (ioa_cfg->sdt_state == READ_DUMP) 8492 ioa_cfg->sdt_state = ABORT_DUMP; 8493 8494 ioa_cfg->dump_timeout = 1; 8495 ipr_cmd->job_step = ipr_reset_alert; 8496 8497 return IPR_RC_JOB_CONTINUE; 8498 } 8499 8500 /** 8501 * ipr_unit_check_no_data - Log a unit check/no data error log 8502 * @ioa_cfg: ioa config struct 8503 * 8504 * Logs an error indicating the adapter unit checked, but for some 8505 * reason, we were unable to fetch the unit check buffer. 8506 * 8507 * Return value: 8508 * nothing 8509 **/ 8510 static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg) 8511 { 8512 ioa_cfg->errors_logged++; 8513 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n"); 8514 } 8515 8516 /** 8517 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA 8518 * @ioa_cfg: ioa config struct 8519 * 8520 * Fetches the unit check buffer from the adapter by clocking the data 8521 * through the mailbox register. 8522 * 8523 * Return value: 8524 * nothing 8525 **/ 8526 static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg) 8527 { 8528 unsigned long mailbox; 8529 struct ipr_hostrcb *hostrcb; 8530 struct ipr_uc_sdt sdt; 8531 int rc, length; 8532 u32 ioasc; 8533 8534 mailbox = readl(ioa_cfg->ioa_mailbox); 8535 8536 if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) { 8537 ipr_unit_check_no_data(ioa_cfg); 8538 return; 8539 } 8540 8541 memset(&sdt, 0, sizeof(struct ipr_uc_sdt)); 8542 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt, 8543 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32)); 8544 8545 if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) || 8546 ((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) && 8547 (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) { 8548 ipr_unit_check_no_data(ioa_cfg); 8549 return; 8550 } 8551 8552 /* Find length of the first sdt entry (UC buffer) */ 8553 if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE) 8554 length = be32_to_cpu(sdt.entry[0].end_token); 8555 else 8556 length = (be32_to_cpu(sdt.entry[0].end_token) - 8557 be32_to_cpu(sdt.entry[0].start_token)) & 8558 IPR_FMT2_MBX_ADDR_MASK; 8559 8560 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next, 8561 struct ipr_hostrcb, queue); 8562 list_del_init(&hostrcb->queue); 8563 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam)); 8564 8565 rc = ipr_get_ldump_data_section(ioa_cfg, 8566 be32_to_cpu(sdt.entry[0].start_token), 8567 (__be32 *)&hostrcb->hcam, 8568 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32)); 8569 8570 if (!rc) { 8571 ipr_handle_log_data(ioa_cfg, hostrcb); 8572 ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc); 8573 if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED && 8574 ioa_cfg->sdt_state == GET_DUMP) 8575 ioa_cfg->sdt_state = WAIT_FOR_DUMP; 8576 } else 8577 ipr_unit_check_no_data(ioa_cfg); 8578 8579 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q); 8580 } 8581 8582 /** 8583 * ipr_reset_get_unit_check_job - Call to get the unit check buffer. 8584 * @ipr_cmd: ipr command struct 8585 * 8586 * Description: This function will call to get the unit check buffer. 8587 * 8588 * Return value: 8589 * IPR_RC_JOB_RETURN 8590 **/ 8591 static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd) 8592 { 8593 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8594 8595 ENTER; 8596 ioa_cfg->ioa_unit_checked = 0; 8597 ipr_get_unit_check_buffer(ioa_cfg); 8598 ipr_cmd->job_step = ipr_reset_alert; 8599 ipr_reset_start_timer(ipr_cmd, 0); 8600 8601 LEAVE; 8602 return IPR_RC_JOB_RETURN; 8603 } 8604 8605 static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd) 8606 { 8607 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8608 8609 ENTER; 8610 8611 if (ioa_cfg->sdt_state != GET_DUMP) 8612 return IPR_RC_JOB_RETURN; 8613 8614 if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left || 8615 (readl(ioa_cfg->regs.sense_interrupt_reg) & 8616 IPR_PCII_MAILBOX_STABLE)) { 8617 8618 if (!ipr_cmd->u.time_left) 8619 dev_err(&ioa_cfg->pdev->dev, 8620 "Timed out waiting for Mailbox register.\n"); 8621 8622 ioa_cfg->sdt_state = READ_DUMP; 8623 ioa_cfg->dump_timeout = 0; 8624 if (ioa_cfg->sis64) 8625 ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT); 8626 else 8627 ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT); 8628 ipr_cmd->job_step = ipr_reset_wait_for_dump; 8629 schedule_work(&ioa_cfg->work_q); 8630 8631 } else { 8632 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT; 8633 ipr_reset_start_timer(ipr_cmd, 8634 IPR_CHECK_FOR_RESET_TIMEOUT); 8635 } 8636 8637 LEAVE; 8638 return IPR_RC_JOB_RETURN; 8639 } 8640 8641 /** 8642 * ipr_reset_restore_cfg_space - Restore PCI config space. 8643 * @ipr_cmd: ipr command struct 8644 * 8645 * Description: This function restores the saved PCI config space of 8646 * the adapter, fails all outstanding ops back to the callers, and 8647 * fetches the dump/unit check if applicable to this reset. 8648 * 8649 * Return value: 8650 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8651 **/ 8652 static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd) 8653 { 8654 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8655 u32 int_reg; 8656 8657 ENTER; 8658 ioa_cfg->pdev->state_saved = true; 8659 pci_restore_state(ioa_cfg->pdev); 8660 8661 if (ipr_set_pcix_cmd_reg(ioa_cfg)) { 8662 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR); 8663 return IPR_RC_JOB_CONTINUE; 8664 } 8665 8666 ipr_fail_all_ops(ioa_cfg); 8667 8668 if (ioa_cfg->sis64) { 8669 /* Set the adapter to the correct endian mode. */ 8670 writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg); 8671 int_reg = readl(ioa_cfg->regs.endian_swap_reg); 8672 } 8673 8674 if (ioa_cfg->ioa_unit_checked) { 8675 if (ioa_cfg->sis64) { 8676 ipr_cmd->job_step = ipr_reset_get_unit_check_job; 8677 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT); 8678 return IPR_RC_JOB_RETURN; 8679 } else { 8680 ioa_cfg->ioa_unit_checked = 0; 8681 ipr_get_unit_check_buffer(ioa_cfg); 8682 ipr_cmd->job_step = ipr_reset_alert; 8683 ipr_reset_start_timer(ipr_cmd, 0); 8684 return IPR_RC_JOB_RETURN; 8685 } 8686 } 8687 8688 if (ioa_cfg->in_ioa_bringdown) { 8689 ipr_cmd->job_step = ipr_ioa_bringdown_done; 8690 } else if (ioa_cfg->sdt_state == GET_DUMP) { 8691 ipr_cmd->job_step = ipr_dump_mailbox_wait; 8692 ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX; 8693 } else { 8694 ipr_cmd->job_step = ipr_reset_enable_ioa; 8695 } 8696 8697 LEAVE; 8698 return IPR_RC_JOB_CONTINUE; 8699 } 8700 8701 /** 8702 * ipr_reset_bist_done - BIST has completed on the adapter. 8703 * @ipr_cmd: ipr command struct 8704 * 8705 * Description: Unblock config space and resume the reset process. 8706 * 8707 * Return value: 8708 * IPR_RC_JOB_CONTINUE 8709 **/ 8710 static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd) 8711 { 8712 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8713 8714 ENTER; 8715 if (ioa_cfg->cfg_locked) 8716 pci_cfg_access_unlock(ioa_cfg->pdev); 8717 ioa_cfg->cfg_locked = 0; 8718 ipr_cmd->job_step = ipr_reset_restore_cfg_space; 8719 LEAVE; 8720 return IPR_RC_JOB_CONTINUE; 8721 } 8722 8723 /** 8724 * ipr_reset_start_bist - Run BIST on the adapter. 8725 * @ipr_cmd: ipr command struct 8726 * 8727 * Description: This function runs BIST on the adapter, then delays 2 seconds. 8728 * 8729 * Return value: 8730 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8731 **/ 8732 static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd) 8733 { 8734 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8735 int rc = PCIBIOS_SUCCESSFUL; 8736 8737 ENTER; 8738 if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO) 8739 writel(IPR_UPROCI_SIS64_START_BIST, 8740 ioa_cfg->regs.set_uproc_interrupt_reg32); 8741 else 8742 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START); 8743 8744 if (rc == PCIBIOS_SUCCESSFUL) { 8745 ipr_cmd->job_step = ipr_reset_bist_done; 8746 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT); 8747 rc = IPR_RC_JOB_RETURN; 8748 } else { 8749 if (ioa_cfg->cfg_locked) 8750 pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev); 8751 ioa_cfg->cfg_locked = 0; 8752 ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR); 8753 rc = IPR_RC_JOB_CONTINUE; 8754 } 8755 8756 LEAVE; 8757 return rc; 8758 } 8759 8760 /** 8761 * ipr_reset_slot_reset_done - Clear PCI reset to the adapter 8762 * @ipr_cmd: ipr command struct 8763 * 8764 * Description: This clears PCI reset to the adapter and delays two seconds. 8765 * 8766 * Return value: 8767 * IPR_RC_JOB_RETURN 8768 **/ 8769 static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd) 8770 { 8771 ENTER; 8772 ipr_cmd->job_step = ipr_reset_bist_done; 8773 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT); 8774 LEAVE; 8775 return IPR_RC_JOB_RETURN; 8776 } 8777 8778 /** 8779 * ipr_reset_reset_work - Pulse a PCIe fundamental reset 8780 * @work: work struct 8781 * 8782 * Description: This pulses warm reset to a slot. 8783 * 8784 **/ 8785 static void ipr_reset_reset_work(struct work_struct *work) 8786 { 8787 struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work); 8788 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8789 struct pci_dev *pdev = ioa_cfg->pdev; 8790 unsigned long lock_flags = 0; 8791 8792 ENTER; 8793 pci_set_pcie_reset_state(pdev, pcie_warm_reset); 8794 msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT)); 8795 pci_set_pcie_reset_state(pdev, pcie_deassert_reset); 8796 8797 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 8798 if (ioa_cfg->reset_cmd == ipr_cmd) 8799 ipr_reset_ioa_job(ipr_cmd); 8800 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 8801 LEAVE; 8802 } 8803 8804 /** 8805 * ipr_reset_slot_reset - Reset the PCI slot of the adapter. 8806 * @ipr_cmd: ipr command struct 8807 * 8808 * Description: This asserts PCI reset to the adapter. 8809 * 8810 * Return value: 8811 * IPR_RC_JOB_RETURN 8812 **/ 8813 static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd) 8814 { 8815 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8816 8817 ENTER; 8818 INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work); 8819 queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work); 8820 ipr_cmd->job_step = ipr_reset_slot_reset_done; 8821 LEAVE; 8822 return IPR_RC_JOB_RETURN; 8823 } 8824 8825 /** 8826 * ipr_reset_block_config_access_wait - Wait for permission to block config access 8827 * @ipr_cmd: ipr command struct 8828 * 8829 * Description: This attempts to block config access to the IOA. 8830 * 8831 * Return value: 8832 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8833 **/ 8834 static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd) 8835 { 8836 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8837 int rc = IPR_RC_JOB_CONTINUE; 8838 8839 if (pci_cfg_access_trylock(ioa_cfg->pdev)) { 8840 ioa_cfg->cfg_locked = 1; 8841 ipr_cmd->job_step = ioa_cfg->reset; 8842 } else { 8843 if (ipr_cmd->u.time_left) { 8844 rc = IPR_RC_JOB_RETURN; 8845 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT; 8846 ipr_reset_start_timer(ipr_cmd, 8847 IPR_CHECK_FOR_RESET_TIMEOUT); 8848 } else { 8849 ipr_cmd->job_step = ioa_cfg->reset; 8850 dev_err(&ioa_cfg->pdev->dev, 8851 "Timed out waiting to lock config access. Resetting anyway.\n"); 8852 } 8853 } 8854 8855 return rc; 8856 } 8857 8858 /** 8859 * ipr_reset_block_config_access - Block config access to the IOA 8860 * @ipr_cmd: ipr command struct 8861 * 8862 * Description: This attempts to block config access to the IOA 8863 * 8864 * Return value: 8865 * IPR_RC_JOB_CONTINUE 8866 **/ 8867 static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd) 8868 { 8869 ipr_cmd->ioa_cfg->cfg_locked = 0; 8870 ipr_cmd->job_step = ipr_reset_block_config_access_wait; 8871 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT; 8872 return IPR_RC_JOB_CONTINUE; 8873 } 8874 8875 /** 8876 * ipr_reset_allowed - Query whether or not IOA can be reset 8877 * @ioa_cfg: ioa config struct 8878 * 8879 * Return value: 8880 * 0 if reset not allowed / non-zero if reset is allowed 8881 **/ 8882 static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg) 8883 { 8884 volatile u32 temp_reg; 8885 8886 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg); 8887 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0); 8888 } 8889 8890 /** 8891 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA. 8892 * @ipr_cmd: ipr command struct 8893 * 8894 * Description: This function waits for adapter permission to run BIST, 8895 * then runs BIST. If the adapter does not give permission after a 8896 * reasonable time, we will reset the adapter anyway. The impact of 8897 * resetting the adapter without warning the adapter is the risk of 8898 * losing the persistent error log on the adapter. If the adapter is 8899 * reset while it is writing to the flash on the adapter, the flash 8900 * segment will have bad ECC and be zeroed. 8901 * 8902 * Return value: 8903 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 8904 **/ 8905 static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd) 8906 { 8907 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8908 int rc = IPR_RC_JOB_RETURN; 8909 8910 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) { 8911 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT; 8912 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT); 8913 } else { 8914 ipr_cmd->job_step = ipr_reset_block_config_access; 8915 rc = IPR_RC_JOB_CONTINUE; 8916 } 8917 8918 return rc; 8919 } 8920 8921 /** 8922 * ipr_reset_alert - Alert the adapter of a pending reset 8923 * @ipr_cmd: ipr command struct 8924 * 8925 * Description: This function alerts the adapter that it will be reset. 8926 * If memory space is not currently enabled, proceed directly 8927 * to running BIST on the adapter. The timer must always be started 8928 * so we guarantee we do not run BIST from ipr_isr. 8929 * 8930 * Return value: 8931 * IPR_RC_JOB_RETURN 8932 **/ 8933 static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd) 8934 { 8935 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8936 u16 cmd_reg; 8937 int rc; 8938 8939 ENTER; 8940 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg); 8941 8942 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) { 8943 ipr_mask_and_clear_interrupts(ioa_cfg, ~0); 8944 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32); 8945 ipr_cmd->job_step = ipr_reset_wait_to_start_bist; 8946 } else { 8947 ipr_cmd->job_step = ipr_reset_block_config_access; 8948 } 8949 8950 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT; 8951 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT); 8952 8953 LEAVE; 8954 return IPR_RC_JOB_RETURN; 8955 } 8956 8957 /** 8958 * ipr_reset_quiesce_done - Complete IOA disconnect 8959 * @ipr_cmd: ipr command struct 8960 * 8961 * Description: Freeze the adapter to complete quiesce processing 8962 * 8963 * Return value: 8964 * IPR_RC_JOB_CONTINUE 8965 **/ 8966 static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd) 8967 { 8968 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8969 8970 ENTER; 8971 ipr_cmd->job_step = ipr_ioa_bringdown_done; 8972 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); 8973 LEAVE; 8974 return IPR_RC_JOB_CONTINUE; 8975 } 8976 8977 /** 8978 * ipr_reset_cancel_hcam_done - Check for outstanding commands 8979 * @ipr_cmd: ipr command struct 8980 * 8981 * Description: Ensure nothing is outstanding to the IOA and 8982 * proceed with IOA disconnect. Otherwise reset the IOA. 8983 * 8984 * Return value: 8985 * IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE 8986 **/ 8987 static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd) 8988 { 8989 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 8990 struct ipr_cmnd *loop_cmd; 8991 struct ipr_hrr_queue *hrrq; 8992 int rc = IPR_RC_JOB_CONTINUE; 8993 int count = 0; 8994 8995 ENTER; 8996 ipr_cmd->job_step = ipr_reset_quiesce_done; 8997 8998 for_each_hrrq(hrrq, ioa_cfg) { 8999 spin_lock(&hrrq->_lock); 9000 list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) { 9001 count++; 9002 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 9003 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 9004 rc = IPR_RC_JOB_RETURN; 9005 break; 9006 } 9007 spin_unlock(&hrrq->_lock); 9008 9009 if (count) 9010 break; 9011 } 9012 9013 LEAVE; 9014 return rc; 9015 } 9016 9017 /** 9018 * ipr_reset_cancel_hcam - Cancel outstanding HCAMs 9019 * @ipr_cmd: ipr command struct 9020 * 9021 * Description: Cancel any oustanding HCAMs to the IOA. 9022 * 9023 * Return value: 9024 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 9025 **/ 9026 static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd) 9027 { 9028 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9029 int rc = IPR_RC_JOB_CONTINUE; 9030 struct ipr_cmd_pkt *cmd_pkt; 9031 struct ipr_cmnd *hcam_cmd; 9032 struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ]; 9033 9034 ENTER; 9035 ipr_cmd->job_step = ipr_reset_cancel_hcam_done; 9036 9037 if (!hrrq->ioa_is_dead) { 9038 if (!list_empty(&ioa_cfg->hostrcb_pending_q)) { 9039 list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) { 9040 if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC) 9041 continue; 9042 9043 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 9044 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 9045 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt; 9046 cmd_pkt->request_type = IPR_RQTYPE_IOACMD; 9047 cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST; 9048 cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB; 9049 cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff; 9050 cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff; 9051 cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff; 9052 cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff; 9053 cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff; 9054 cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff; 9055 cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff; 9056 cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff; 9057 9058 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, 9059 IPR_CANCEL_TIMEOUT); 9060 9061 rc = IPR_RC_JOB_RETURN; 9062 ipr_cmd->job_step = ipr_reset_cancel_hcam; 9063 break; 9064 } 9065 } 9066 } else 9067 ipr_cmd->job_step = ipr_reset_alert; 9068 9069 LEAVE; 9070 return rc; 9071 } 9072 9073 /** 9074 * ipr_reset_ucode_download_done - Microcode download completion 9075 * @ipr_cmd: ipr command struct 9076 * 9077 * Description: This function unmaps the microcode download buffer. 9078 * 9079 * Return value: 9080 * IPR_RC_JOB_CONTINUE 9081 **/ 9082 static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd) 9083 { 9084 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9085 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist; 9086 9087 dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist, 9088 sglist->num_sg, DMA_TO_DEVICE); 9089 9090 ipr_cmd->job_step = ipr_reset_alert; 9091 return IPR_RC_JOB_CONTINUE; 9092 } 9093 9094 /** 9095 * ipr_reset_ucode_download - Download microcode to the adapter 9096 * @ipr_cmd: ipr command struct 9097 * 9098 * Description: This function checks to see if it there is microcode 9099 * to download to the adapter. If there is, a download is performed. 9100 * 9101 * Return value: 9102 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 9103 **/ 9104 static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd) 9105 { 9106 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9107 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist; 9108 9109 ENTER; 9110 ipr_cmd->job_step = ipr_reset_alert; 9111 9112 if (!sglist) 9113 return IPR_RC_JOB_CONTINUE; 9114 9115 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 9116 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB; 9117 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER; 9118 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE; 9119 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16; 9120 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8; 9121 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff; 9122 9123 if (ioa_cfg->sis64) 9124 ipr_build_ucode_ioadl64(ipr_cmd, sglist); 9125 else 9126 ipr_build_ucode_ioadl(ipr_cmd, sglist); 9127 ipr_cmd->job_step = ipr_reset_ucode_download_done; 9128 9129 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, 9130 IPR_WRITE_BUFFER_TIMEOUT); 9131 9132 LEAVE; 9133 return IPR_RC_JOB_RETURN; 9134 } 9135 9136 /** 9137 * ipr_reset_shutdown_ioa - Shutdown the adapter 9138 * @ipr_cmd: ipr command struct 9139 * 9140 * Description: This function issues an adapter shutdown of the 9141 * specified type to the specified adapter as part of the 9142 * adapter reset job. 9143 * 9144 * Return value: 9145 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN 9146 **/ 9147 static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd) 9148 { 9149 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9150 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type; 9151 unsigned long timeout; 9152 int rc = IPR_RC_JOB_CONTINUE; 9153 9154 ENTER; 9155 if (shutdown_type == IPR_SHUTDOWN_QUIESCE) 9156 ipr_cmd->job_step = ipr_reset_cancel_hcam; 9157 else if (shutdown_type != IPR_SHUTDOWN_NONE && 9158 !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) { 9159 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 9160 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 9161 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN; 9162 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type; 9163 9164 if (shutdown_type == IPR_SHUTDOWN_NORMAL) 9165 timeout = IPR_SHUTDOWN_TIMEOUT; 9166 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL) 9167 timeout = IPR_INTERNAL_TIMEOUT; 9168 else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid) 9169 timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO; 9170 else 9171 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT; 9172 9173 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout); 9174 9175 rc = IPR_RC_JOB_RETURN; 9176 ipr_cmd->job_step = ipr_reset_ucode_download; 9177 } else 9178 ipr_cmd->job_step = ipr_reset_alert; 9179 9180 LEAVE; 9181 return rc; 9182 } 9183 9184 /** 9185 * ipr_reset_ioa_job - Adapter reset job 9186 * @ipr_cmd: ipr command struct 9187 * 9188 * Description: This function is the job router for the adapter reset job. 9189 * 9190 * Return value: 9191 * none 9192 **/ 9193 static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd) 9194 { 9195 u32 rc, ioasc; 9196 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9197 9198 do { 9199 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc); 9200 9201 if (ioa_cfg->reset_cmd != ipr_cmd) { 9202 /* 9203 * We are doing nested adapter resets and this is 9204 * not the current reset job. 9205 */ 9206 list_add_tail(&ipr_cmd->queue, 9207 &ipr_cmd->hrrq->hrrq_free_q); 9208 return; 9209 } 9210 9211 if (IPR_IOASC_SENSE_KEY(ioasc)) { 9212 rc = ipr_cmd->job_step_failed(ipr_cmd); 9213 if (rc == IPR_RC_JOB_RETURN) 9214 return; 9215 } 9216 9217 ipr_reinit_ipr_cmnd(ipr_cmd); 9218 ipr_cmd->job_step_failed = ipr_reset_cmd_failed; 9219 rc = ipr_cmd->job_step(ipr_cmd); 9220 } while (rc == IPR_RC_JOB_CONTINUE); 9221 } 9222 9223 /** 9224 * _ipr_initiate_ioa_reset - Initiate an adapter reset 9225 * @ioa_cfg: ioa config struct 9226 * @job_step: first job step of reset job 9227 * @shutdown_type: shutdown type 9228 * 9229 * Description: This function will initiate the reset of the given adapter 9230 * starting at the selected job step. 9231 * If the caller needs to wait on the completion of the reset, 9232 * the caller must sleep on the reset_wait_q. 9233 * 9234 * Return value: 9235 * none 9236 **/ 9237 static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg, 9238 int (*job_step) (struct ipr_cmnd *), 9239 enum ipr_shutdown_type shutdown_type) 9240 { 9241 struct ipr_cmnd *ipr_cmd; 9242 int i; 9243 9244 ioa_cfg->in_reset_reload = 1; 9245 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9246 spin_lock(&ioa_cfg->hrrq[i]._lock); 9247 ioa_cfg->hrrq[i].allow_cmds = 0; 9248 spin_unlock(&ioa_cfg->hrrq[i]._lock); 9249 } 9250 wmb(); 9251 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) { 9252 ioa_cfg->scsi_unblock = 0; 9253 ioa_cfg->scsi_blocked = 1; 9254 scsi_block_requests(ioa_cfg->host); 9255 } 9256 9257 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg); 9258 ioa_cfg->reset_cmd = ipr_cmd; 9259 ipr_cmd->job_step = job_step; 9260 ipr_cmd->u.shutdown_type = shutdown_type; 9261 9262 ipr_reset_ioa_job(ipr_cmd); 9263 } 9264 9265 /** 9266 * ipr_initiate_ioa_reset - Initiate an adapter reset 9267 * @ioa_cfg: ioa config struct 9268 * @shutdown_type: shutdown type 9269 * 9270 * Description: This function will initiate the reset of the given adapter. 9271 * If the caller needs to wait on the completion of the reset, 9272 * the caller must sleep on the reset_wait_q. 9273 * 9274 * Return value: 9275 * none 9276 **/ 9277 static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg, 9278 enum ipr_shutdown_type shutdown_type) 9279 { 9280 int i; 9281 9282 if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) 9283 return; 9284 9285 if (ioa_cfg->in_reset_reload) { 9286 if (ioa_cfg->sdt_state == GET_DUMP) 9287 ioa_cfg->sdt_state = WAIT_FOR_DUMP; 9288 else if (ioa_cfg->sdt_state == READ_DUMP) 9289 ioa_cfg->sdt_state = ABORT_DUMP; 9290 } 9291 9292 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) { 9293 dev_err(&ioa_cfg->pdev->dev, 9294 "IOA taken offline - error recovery failed\n"); 9295 9296 ioa_cfg->reset_retries = 0; 9297 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9298 spin_lock(&ioa_cfg->hrrq[i]._lock); 9299 ioa_cfg->hrrq[i].ioa_is_dead = 1; 9300 spin_unlock(&ioa_cfg->hrrq[i]._lock); 9301 } 9302 wmb(); 9303 9304 if (ioa_cfg->in_ioa_bringdown) { 9305 ioa_cfg->reset_cmd = NULL; 9306 ioa_cfg->in_reset_reload = 0; 9307 ipr_fail_all_ops(ioa_cfg); 9308 wake_up_all(&ioa_cfg->reset_wait_q); 9309 9310 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) { 9311 ioa_cfg->scsi_unblock = 1; 9312 schedule_work(&ioa_cfg->work_q); 9313 } 9314 return; 9315 } else { 9316 ioa_cfg->in_ioa_bringdown = 1; 9317 shutdown_type = IPR_SHUTDOWN_NONE; 9318 } 9319 } 9320 9321 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa, 9322 shutdown_type); 9323 } 9324 9325 /** 9326 * ipr_reset_freeze - Hold off all I/O activity 9327 * @ipr_cmd: ipr command struct 9328 * 9329 * Description: If the PCI slot is frozen, hold off all I/O 9330 * activity; then, as soon as the slot is available again, 9331 * initiate an adapter reset. 9332 */ 9333 static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd) 9334 { 9335 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg; 9336 int i; 9337 9338 /* Disallow new interrupts, avoid loop */ 9339 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9340 spin_lock(&ioa_cfg->hrrq[i]._lock); 9341 ioa_cfg->hrrq[i].allow_interrupts = 0; 9342 spin_unlock(&ioa_cfg->hrrq[i]._lock); 9343 } 9344 wmb(); 9345 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q); 9346 ipr_cmd->done = ipr_reset_ioa_job; 9347 return IPR_RC_JOB_RETURN; 9348 } 9349 9350 /** 9351 * ipr_pci_mmio_enabled - Called when MMIO has been re-enabled 9352 * @pdev: PCI device struct 9353 * 9354 * Description: This routine is called to tell us that the MMIO 9355 * access to the IOA has been restored 9356 */ 9357 static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev) 9358 { 9359 unsigned long flags = 0; 9360 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 9361 9362 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 9363 if (!ioa_cfg->probe_done) 9364 pci_save_state(pdev); 9365 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 9366 return PCI_ERS_RESULT_NEED_RESET; 9367 } 9368 9369 /** 9370 * ipr_pci_frozen - Called when slot has experienced a PCI bus error. 9371 * @pdev: PCI device struct 9372 * 9373 * Description: This routine is called to tell us that the PCI bus 9374 * is down. Can't do anything here, except put the device driver 9375 * into a holding pattern, waiting for the PCI bus to come back. 9376 */ 9377 static void ipr_pci_frozen(struct pci_dev *pdev) 9378 { 9379 unsigned long flags = 0; 9380 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 9381 9382 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 9383 if (ioa_cfg->probe_done) 9384 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE); 9385 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 9386 } 9387 9388 /** 9389 * ipr_pci_slot_reset - Called when PCI slot has been reset. 9390 * @pdev: PCI device struct 9391 * 9392 * Description: This routine is called by the pci error recovery 9393 * code after the PCI slot has been reset, just before we 9394 * should resume normal operations. 9395 */ 9396 static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev) 9397 { 9398 unsigned long flags = 0; 9399 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 9400 9401 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 9402 if (ioa_cfg->probe_done) { 9403 if (ioa_cfg->needs_warm_reset) 9404 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 9405 else 9406 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space, 9407 IPR_SHUTDOWN_NONE); 9408 } else 9409 wake_up_all(&ioa_cfg->eeh_wait_q); 9410 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 9411 return PCI_ERS_RESULT_RECOVERED; 9412 } 9413 9414 /** 9415 * ipr_pci_perm_failure - Called when PCI slot is dead for good. 9416 * @pdev: PCI device struct 9417 * 9418 * Description: This routine is called when the PCI bus has 9419 * permanently failed. 9420 */ 9421 static void ipr_pci_perm_failure(struct pci_dev *pdev) 9422 { 9423 unsigned long flags = 0; 9424 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 9425 int i; 9426 9427 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 9428 if (ioa_cfg->probe_done) { 9429 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP) 9430 ioa_cfg->sdt_state = ABORT_DUMP; 9431 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1; 9432 ioa_cfg->in_ioa_bringdown = 1; 9433 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9434 spin_lock(&ioa_cfg->hrrq[i]._lock); 9435 ioa_cfg->hrrq[i].allow_cmds = 0; 9436 spin_unlock(&ioa_cfg->hrrq[i]._lock); 9437 } 9438 wmb(); 9439 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 9440 } else 9441 wake_up_all(&ioa_cfg->eeh_wait_q); 9442 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 9443 } 9444 9445 /** 9446 * ipr_pci_error_detected - Called when a PCI error is detected. 9447 * @pdev: PCI device struct 9448 * @state: PCI channel state 9449 * 9450 * Description: Called when a PCI error is detected. 9451 * 9452 * Return value: 9453 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT 9454 */ 9455 static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev, 9456 pci_channel_state_t state) 9457 { 9458 switch (state) { 9459 case pci_channel_io_frozen: 9460 ipr_pci_frozen(pdev); 9461 return PCI_ERS_RESULT_CAN_RECOVER; 9462 case pci_channel_io_perm_failure: 9463 ipr_pci_perm_failure(pdev); 9464 return PCI_ERS_RESULT_DISCONNECT; 9465 break; 9466 default: 9467 break; 9468 } 9469 return PCI_ERS_RESULT_NEED_RESET; 9470 } 9471 9472 /** 9473 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..) 9474 * @ioa_cfg: ioa cfg struct 9475 * 9476 * Description: This is the second phase of adapter initialization 9477 * This function takes care of initilizing the adapter to the point 9478 * where it can accept new commands. 9479 9480 * Return value: 9481 * 0 on success / -EIO on failure 9482 **/ 9483 static int ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg) 9484 { 9485 int rc = 0; 9486 unsigned long host_lock_flags = 0; 9487 9488 ENTER; 9489 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags); 9490 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg); 9491 ioa_cfg->probe_done = 1; 9492 if (ioa_cfg->needs_hard_reset) { 9493 ioa_cfg->needs_hard_reset = 0; 9494 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE); 9495 } else 9496 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa, 9497 IPR_SHUTDOWN_NONE); 9498 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags); 9499 9500 LEAVE; 9501 return rc; 9502 } 9503 9504 /** 9505 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter 9506 * @ioa_cfg: ioa config struct 9507 * 9508 * Return value: 9509 * none 9510 **/ 9511 static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg) 9512 { 9513 int i; 9514 9515 if (ioa_cfg->ipr_cmnd_list) { 9516 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) { 9517 if (ioa_cfg->ipr_cmnd_list[i]) 9518 dma_pool_free(ioa_cfg->ipr_cmd_pool, 9519 ioa_cfg->ipr_cmnd_list[i], 9520 ioa_cfg->ipr_cmnd_list_dma[i]); 9521 9522 ioa_cfg->ipr_cmnd_list[i] = NULL; 9523 } 9524 } 9525 9526 if (ioa_cfg->ipr_cmd_pool) 9527 dma_pool_destroy(ioa_cfg->ipr_cmd_pool); 9528 9529 kfree(ioa_cfg->ipr_cmnd_list); 9530 kfree(ioa_cfg->ipr_cmnd_list_dma); 9531 ioa_cfg->ipr_cmnd_list = NULL; 9532 ioa_cfg->ipr_cmnd_list_dma = NULL; 9533 ioa_cfg->ipr_cmd_pool = NULL; 9534 } 9535 9536 /** 9537 * ipr_free_mem - Frees memory allocated for an adapter 9538 * @ioa_cfg: ioa cfg struct 9539 * 9540 * Return value: 9541 * nothing 9542 **/ 9543 static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg) 9544 { 9545 int i; 9546 9547 kfree(ioa_cfg->res_entries); 9548 dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs), 9549 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma); 9550 ipr_free_cmd_blks(ioa_cfg); 9551 9552 for (i = 0; i < ioa_cfg->hrrq_num; i++) 9553 dma_free_coherent(&ioa_cfg->pdev->dev, 9554 sizeof(u32) * ioa_cfg->hrrq[i].size, 9555 ioa_cfg->hrrq[i].host_rrq, 9556 ioa_cfg->hrrq[i].host_rrq_dma); 9557 9558 dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size, 9559 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma); 9560 9561 for (i = 0; i < IPR_MAX_HCAMS; i++) { 9562 dma_free_coherent(&ioa_cfg->pdev->dev, 9563 sizeof(struct ipr_hostrcb), 9564 ioa_cfg->hostrcb[i], 9565 ioa_cfg->hostrcb_dma[i]); 9566 } 9567 9568 ipr_free_dump(ioa_cfg); 9569 kfree(ioa_cfg->trace); 9570 } 9571 9572 /** 9573 * ipr_free_irqs - Free all allocated IRQs for the adapter. 9574 * @ioa_cfg: ipr cfg struct 9575 * 9576 * This function frees all allocated IRQs for the 9577 * specified adapter. 9578 * 9579 * Return value: 9580 * none 9581 **/ 9582 static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg) 9583 { 9584 struct pci_dev *pdev = ioa_cfg->pdev; 9585 int i; 9586 9587 for (i = 0; i < ioa_cfg->nvectors; i++) 9588 free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]); 9589 pci_free_irq_vectors(pdev); 9590 } 9591 9592 /** 9593 * ipr_free_all_resources - Free all allocated resources for an adapter. 9594 * @ipr_cmd: ipr command struct 9595 * 9596 * This function frees all allocated resources for the 9597 * specified adapter. 9598 * 9599 * Return value: 9600 * none 9601 **/ 9602 static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg) 9603 { 9604 struct pci_dev *pdev = ioa_cfg->pdev; 9605 9606 ENTER; 9607 ipr_free_irqs(ioa_cfg); 9608 if (ioa_cfg->reset_work_q) 9609 destroy_workqueue(ioa_cfg->reset_work_q); 9610 iounmap(ioa_cfg->hdw_dma_regs); 9611 pci_release_regions(pdev); 9612 ipr_free_mem(ioa_cfg); 9613 scsi_host_put(ioa_cfg->host); 9614 pci_disable_device(pdev); 9615 LEAVE; 9616 } 9617 9618 /** 9619 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter 9620 * @ioa_cfg: ioa config struct 9621 * 9622 * Return value: 9623 * 0 on success / -ENOMEM on allocation failure 9624 **/ 9625 static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg) 9626 { 9627 struct ipr_cmnd *ipr_cmd; 9628 struct ipr_ioarcb *ioarcb; 9629 dma_addr_t dma_addr; 9630 int i, entries_each_hrrq, hrrq_id = 0; 9631 9632 ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev, 9633 sizeof(struct ipr_cmnd), 512, 0); 9634 9635 if (!ioa_cfg->ipr_cmd_pool) 9636 return -ENOMEM; 9637 9638 ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL); 9639 ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL); 9640 9641 if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) { 9642 ipr_free_cmd_blks(ioa_cfg); 9643 return -ENOMEM; 9644 } 9645 9646 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9647 if (ioa_cfg->hrrq_num > 1) { 9648 if (i == 0) { 9649 entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS; 9650 ioa_cfg->hrrq[i].min_cmd_id = 0; 9651 ioa_cfg->hrrq[i].max_cmd_id = 9652 (entries_each_hrrq - 1); 9653 } else { 9654 entries_each_hrrq = 9655 IPR_NUM_BASE_CMD_BLKS/ 9656 (ioa_cfg->hrrq_num - 1); 9657 ioa_cfg->hrrq[i].min_cmd_id = 9658 IPR_NUM_INTERNAL_CMD_BLKS + 9659 (i - 1) * entries_each_hrrq; 9660 ioa_cfg->hrrq[i].max_cmd_id = 9661 (IPR_NUM_INTERNAL_CMD_BLKS + 9662 i * entries_each_hrrq - 1); 9663 } 9664 } else { 9665 entries_each_hrrq = IPR_NUM_CMD_BLKS; 9666 ioa_cfg->hrrq[i].min_cmd_id = 0; 9667 ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1); 9668 } 9669 ioa_cfg->hrrq[i].size = entries_each_hrrq; 9670 } 9671 9672 BUG_ON(ioa_cfg->hrrq_num == 0); 9673 9674 i = IPR_NUM_CMD_BLKS - 9675 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1; 9676 if (i > 0) { 9677 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i; 9678 ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i; 9679 } 9680 9681 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) { 9682 ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool, 9683 GFP_KERNEL, &dma_addr); 9684 9685 if (!ipr_cmd) { 9686 ipr_free_cmd_blks(ioa_cfg); 9687 return -ENOMEM; 9688 } 9689 9690 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd; 9691 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr; 9692 9693 ioarcb = &ipr_cmd->ioarcb; 9694 ipr_cmd->dma_addr = dma_addr; 9695 if (ioa_cfg->sis64) 9696 ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr); 9697 else 9698 ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr); 9699 9700 ioarcb->host_response_handle = cpu_to_be32(i << 2); 9701 if (ioa_cfg->sis64) { 9702 ioarcb->u.sis64_addr_data.data_ioadl_addr = 9703 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64)); 9704 ioarcb->u.sis64_addr_data.ioasa_host_pci_addr = 9705 cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64)); 9706 } else { 9707 ioarcb->write_ioadl_addr = 9708 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl)); 9709 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr; 9710 ioarcb->ioasa_host_pci_addr = 9711 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa)); 9712 } 9713 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa)); 9714 ipr_cmd->cmd_index = i; 9715 ipr_cmd->ioa_cfg = ioa_cfg; 9716 ipr_cmd->sense_buffer_dma = dma_addr + 9717 offsetof(struct ipr_cmnd, sense_buffer); 9718 9719 ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id; 9720 ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id]; 9721 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 9722 if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id) 9723 hrrq_id++; 9724 } 9725 9726 return 0; 9727 } 9728 9729 /** 9730 * ipr_alloc_mem - Allocate memory for an adapter 9731 * @ioa_cfg: ioa config struct 9732 * 9733 * Return value: 9734 * 0 on success / non-zero for error 9735 **/ 9736 static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg) 9737 { 9738 struct pci_dev *pdev = ioa_cfg->pdev; 9739 int i, rc = -ENOMEM; 9740 9741 ENTER; 9742 ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported, 9743 sizeof(struct ipr_resource_entry), 9744 GFP_KERNEL); 9745 9746 if (!ioa_cfg->res_entries) 9747 goto out; 9748 9749 for (i = 0; i < ioa_cfg->max_devs_supported; i++) { 9750 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q); 9751 ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg; 9752 } 9753 9754 ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev, 9755 sizeof(struct ipr_misc_cbs), 9756 &ioa_cfg->vpd_cbs_dma, 9757 GFP_KERNEL); 9758 9759 if (!ioa_cfg->vpd_cbs) 9760 goto out_free_res_entries; 9761 9762 if (ipr_alloc_cmd_blks(ioa_cfg)) 9763 goto out_free_vpd_cbs; 9764 9765 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9766 ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev, 9767 sizeof(u32) * ioa_cfg->hrrq[i].size, 9768 &ioa_cfg->hrrq[i].host_rrq_dma, 9769 GFP_KERNEL); 9770 9771 if (!ioa_cfg->hrrq[i].host_rrq) { 9772 while (--i > 0) 9773 dma_free_coherent(&pdev->dev, 9774 sizeof(u32) * ioa_cfg->hrrq[i].size, 9775 ioa_cfg->hrrq[i].host_rrq, 9776 ioa_cfg->hrrq[i].host_rrq_dma); 9777 goto out_ipr_free_cmd_blocks; 9778 } 9779 ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg; 9780 } 9781 9782 ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev, 9783 ioa_cfg->cfg_table_size, 9784 &ioa_cfg->cfg_table_dma, 9785 GFP_KERNEL); 9786 9787 if (!ioa_cfg->u.cfg_table) 9788 goto out_free_host_rrq; 9789 9790 for (i = 0; i < IPR_MAX_HCAMS; i++) { 9791 ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev, 9792 sizeof(struct ipr_hostrcb), 9793 &ioa_cfg->hostrcb_dma[i], 9794 GFP_KERNEL); 9795 9796 if (!ioa_cfg->hostrcb[i]) 9797 goto out_free_hostrcb_dma; 9798 9799 ioa_cfg->hostrcb[i]->hostrcb_dma = 9800 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam); 9801 ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg; 9802 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q); 9803 } 9804 9805 ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES, 9806 sizeof(struct ipr_trace_entry), 9807 GFP_KERNEL); 9808 9809 if (!ioa_cfg->trace) 9810 goto out_free_hostrcb_dma; 9811 9812 rc = 0; 9813 out: 9814 LEAVE; 9815 return rc; 9816 9817 out_free_hostrcb_dma: 9818 while (i-- > 0) { 9819 dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb), 9820 ioa_cfg->hostrcb[i], 9821 ioa_cfg->hostrcb_dma[i]); 9822 } 9823 dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size, 9824 ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma); 9825 out_free_host_rrq: 9826 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 9827 dma_free_coherent(&pdev->dev, 9828 sizeof(u32) * ioa_cfg->hrrq[i].size, 9829 ioa_cfg->hrrq[i].host_rrq, 9830 ioa_cfg->hrrq[i].host_rrq_dma); 9831 } 9832 out_ipr_free_cmd_blocks: 9833 ipr_free_cmd_blks(ioa_cfg); 9834 out_free_vpd_cbs: 9835 dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs), 9836 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma); 9837 out_free_res_entries: 9838 kfree(ioa_cfg->res_entries); 9839 goto out; 9840 } 9841 9842 /** 9843 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values 9844 * @ioa_cfg: ioa config struct 9845 * 9846 * Return value: 9847 * none 9848 **/ 9849 static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg) 9850 { 9851 int i; 9852 9853 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) { 9854 ioa_cfg->bus_attr[i].bus = i; 9855 ioa_cfg->bus_attr[i].qas_enabled = 0; 9856 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH; 9857 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds)) 9858 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed]; 9859 else 9860 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE; 9861 } 9862 } 9863 9864 /** 9865 * ipr_init_regs - Initialize IOA registers 9866 * @ioa_cfg: ioa config struct 9867 * 9868 * Return value: 9869 * none 9870 **/ 9871 static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg) 9872 { 9873 const struct ipr_interrupt_offsets *p; 9874 struct ipr_interrupts *t; 9875 void __iomem *base; 9876 9877 p = &ioa_cfg->chip_cfg->regs; 9878 t = &ioa_cfg->regs; 9879 base = ioa_cfg->hdw_dma_regs; 9880 9881 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg; 9882 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg; 9883 t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32; 9884 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg; 9885 t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32; 9886 t->clr_interrupt_reg = base + p->clr_interrupt_reg; 9887 t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32; 9888 t->sense_interrupt_reg = base + p->sense_interrupt_reg; 9889 t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32; 9890 t->ioarrin_reg = base + p->ioarrin_reg; 9891 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg; 9892 t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32; 9893 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg; 9894 t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32; 9895 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg; 9896 t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32; 9897 9898 if (ioa_cfg->sis64) { 9899 t->init_feedback_reg = base + p->init_feedback_reg; 9900 t->dump_addr_reg = base + p->dump_addr_reg; 9901 t->dump_data_reg = base + p->dump_data_reg; 9902 t->endian_swap_reg = base + p->endian_swap_reg; 9903 } 9904 } 9905 9906 /** 9907 * ipr_init_ioa_cfg - Initialize IOA config struct 9908 * @ioa_cfg: ioa config struct 9909 * @host: scsi host struct 9910 * @pdev: PCI dev struct 9911 * 9912 * Return value: 9913 * none 9914 **/ 9915 static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg, 9916 struct Scsi_Host *host, struct pci_dev *pdev) 9917 { 9918 int i; 9919 9920 ioa_cfg->host = host; 9921 ioa_cfg->pdev = pdev; 9922 ioa_cfg->log_level = ipr_log_level; 9923 ioa_cfg->doorbell = IPR_DOORBELL; 9924 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER); 9925 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL); 9926 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START); 9927 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL); 9928 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL); 9929 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL); 9930 9931 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q); 9932 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q); 9933 INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q); 9934 INIT_LIST_HEAD(&ioa_cfg->free_res_q); 9935 INIT_LIST_HEAD(&ioa_cfg->used_res_q); 9936 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread); 9937 INIT_WORK(&ioa_cfg->scsi_add_work_q, ipr_add_remove_thread); 9938 init_waitqueue_head(&ioa_cfg->reset_wait_q); 9939 init_waitqueue_head(&ioa_cfg->msi_wait_q); 9940 init_waitqueue_head(&ioa_cfg->eeh_wait_q); 9941 ioa_cfg->sdt_state = INACTIVE; 9942 9943 ipr_initialize_bus_attr(ioa_cfg); 9944 ioa_cfg->max_devs_supported = ipr_max_devs; 9945 9946 if (ioa_cfg->sis64) { 9947 host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS; 9948 host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET; 9949 if (ipr_max_devs > IPR_MAX_SIS64_DEVS) 9950 ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS; 9951 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64) 9952 + ((sizeof(struct ipr_config_table_entry64) 9953 * ioa_cfg->max_devs_supported))); 9954 } else { 9955 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS; 9956 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET; 9957 if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS) 9958 ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS; 9959 ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr) 9960 + ((sizeof(struct ipr_config_table_entry) 9961 * ioa_cfg->max_devs_supported))); 9962 } 9963 9964 host->max_channel = IPR_VSET_BUS; 9965 host->unique_id = host->host_no; 9966 host->max_cmd_len = IPR_MAX_CDB_LEN; 9967 host->can_queue = ioa_cfg->max_cmds; 9968 pci_set_drvdata(pdev, ioa_cfg); 9969 9970 for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) { 9971 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q); 9972 INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q); 9973 spin_lock_init(&ioa_cfg->hrrq[i]._lock); 9974 if (i == 0) 9975 ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock; 9976 else 9977 ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock; 9978 } 9979 } 9980 9981 /** 9982 * ipr_get_chip_info - Find adapter chip information 9983 * @dev_id: PCI device id struct 9984 * 9985 * Return value: 9986 * ptr to chip information on success / NULL on failure 9987 **/ 9988 static const struct ipr_chip_t * 9989 ipr_get_chip_info(const struct pci_device_id *dev_id) 9990 { 9991 int i; 9992 9993 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++) 9994 if (ipr_chip[i].vendor == dev_id->vendor && 9995 ipr_chip[i].device == dev_id->device) 9996 return &ipr_chip[i]; 9997 return NULL; 9998 } 9999 10000 /** 10001 * ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete 10002 * during probe time 10003 * @ioa_cfg: ioa config struct 10004 * 10005 * Return value: 10006 * None 10007 **/ 10008 static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg) 10009 { 10010 struct pci_dev *pdev = ioa_cfg->pdev; 10011 10012 if (pci_channel_offline(pdev)) { 10013 wait_event_timeout(ioa_cfg->eeh_wait_q, 10014 !pci_channel_offline(pdev), 10015 IPR_PCI_ERROR_RECOVERY_TIMEOUT); 10016 pci_restore_state(pdev); 10017 } 10018 } 10019 10020 static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg) 10021 { 10022 int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1; 10023 10024 for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) { 10025 snprintf(ioa_cfg->vectors_info[vec_idx].desc, n, 10026 "host%d-%d", ioa_cfg->host->host_no, vec_idx); 10027 ioa_cfg->vectors_info[vec_idx]. 10028 desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0; 10029 } 10030 } 10031 10032 static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg, 10033 struct pci_dev *pdev) 10034 { 10035 int i, rc; 10036 10037 for (i = 1; i < ioa_cfg->nvectors; i++) { 10038 rc = request_irq(pci_irq_vector(pdev, i), 10039 ipr_isr_mhrrq, 10040 0, 10041 ioa_cfg->vectors_info[i].desc, 10042 &ioa_cfg->hrrq[i]); 10043 if (rc) { 10044 while (--i >= 0) 10045 free_irq(pci_irq_vector(pdev, i), 10046 &ioa_cfg->hrrq[i]); 10047 return rc; 10048 } 10049 } 10050 return 0; 10051 } 10052 10053 /** 10054 * ipr_test_intr - Handle the interrupt generated in ipr_test_msi(). 10055 * @pdev: PCI device struct 10056 * 10057 * Description: Simply set the msi_received flag to 1 indicating that 10058 * Message Signaled Interrupts are supported. 10059 * 10060 * Return value: 10061 * 0 on success / non-zero on failure 10062 **/ 10063 static irqreturn_t ipr_test_intr(int irq, void *devp) 10064 { 10065 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp; 10066 unsigned long lock_flags = 0; 10067 irqreturn_t rc = IRQ_HANDLED; 10068 10069 dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq); 10070 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10071 10072 ioa_cfg->msi_received = 1; 10073 wake_up(&ioa_cfg->msi_wait_q); 10074 10075 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10076 return rc; 10077 } 10078 10079 /** 10080 * ipr_test_msi - Test for Message Signaled Interrupt (MSI) support. 10081 * @pdev: PCI device struct 10082 * 10083 * Description: This routine sets up and initiates a test interrupt to determine 10084 * if the interrupt is received via the ipr_test_intr() service routine. 10085 * If the tests fails, the driver will fall back to LSI. 10086 * 10087 * Return value: 10088 * 0 on success / non-zero on failure 10089 **/ 10090 static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev) 10091 { 10092 int rc; 10093 volatile u32 int_reg; 10094 unsigned long lock_flags = 0; 10095 int irq = pci_irq_vector(pdev, 0); 10096 10097 ENTER; 10098 10099 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10100 init_waitqueue_head(&ioa_cfg->msi_wait_q); 10101 ioa_cfg->msi_received = 0; 10102 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); 10103 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32); 10104 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg); 10105 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10106 10107 rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg); 10108 if (rc) { 10109 dev_err(&pdev->dev, "Can not assign irq %d\n", irq); 10110 return rc; 10111 } else if (ipr_debug) 10112 dev_info(&pdev->dev, "IRQ assigned: %d\n", irq); 10113 10114 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32); 10115 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg); 10116 wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ); 10117 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10118 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); 10119 10120 if (!ioa_cfg->msi_received) { 10121 /* MSI test failed */ 10122 dev_info(&pdev->dev, "MSI test failed. Falling back to LSI.\n"); 10123 rc = -EOPNOTSUPP; 10124 } else if (ipr_debug) 10125 dev_info(&pdev->dev, "MSI test succeeded.\n"); 10126 10127 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10128 10129 free_irq(irq, ioa_cfg); 10130 10131 LEAVE; 10132 10133 return rc; 10134 } 10135 10136 /* ipr_probe_ioa - Allocates memory and does first stage of initialization 10137 * @pdev: PCI device struct 10138 * @dev_id: PCI device id struct 10139 * 10140 * Return value: 10141 * 0 on success / non-zero on failure 10142 **/ 10143 static int ipr_probe_ioa(struct pci_dev *pdev, 10144 const struct pci_device_id *dev_id) 10145 { 10146 struct ipr_ioa_cfg *ioa_cfg; 10147 struct Scsi_Host *host; 10148 unsigned long ipr_regs_pci; 10149 void __iomem *ipr_regs; 10150 int rc = PCIBIOS_SUCCESSFUL; 10151 volatile u32 mask, uproc, interrupts; 10152 unsigned long lock_flags, driver_lock_flags; 10153 unsigned int irq_flag; 10154 10155 ENTER; 10156 10157 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq); 10158 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg)); 10159 10160 if (!host) { 10161 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n"); 10162 rc = -ENOMEM; 10163 goto out; 10164 } 10165 10166 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata; 10167 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg)); 10168 ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops); 10169 10170 ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id); 10171 10172 if (!ioa_cfg->ipr_chip) { 10173 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n", 10174 dev_id->vendor, dev_id->device); 10175 goto out_scsi_host_put; 10176 } 10177 10178 /* set SIS 32 or SIS 64 */ 10179 ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0; 10180 ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg; 10181 ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr; 10182 ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds; 10183 10184 if (ipr_transop_timeout) 10185 ioa_cfg->transop_timeout = ipr_transop_timeout; 10186 else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT) 10187 ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT; 10188 else 10189 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT; 10190 10191 ioa_cfg->revid = pdev->revision; 10192 10193 ipr_init_ioa_cfg(ioa_cfg, host, pdev); 10194 10195 ipr_regs_pci = pci_resource_start(pdev, 0); 10196 10197 rc = pci_request_regions(pdev, IPR_NAME); 10198 if (rc < 0) { 10199 dev_err(&pdev->dev, 10200 "Couldn't register memory range of registers\n"); 10201 goto out_scsi_host_put; 10202 } 10203 10204 rc = pci_enable_device(pdev); 10205 10206 if (rc || pci_channel_offline(pdev)) { 10207 if (pci_channel_offline(pdev)) { 10208 ipr_wait_for_pci_err_recovery(ioa_cfg); 10209 rc = pci_enable_device(pdev); 10210 } 10211 10212 if (rc) { 10213 dev_err(&pdev->dev, "Cannot enable adapter\n"); 10214 ipr_wait_for_pci_err_recovery(ioa_cfg); 10215 goto out_release_regions; 10216 } 10217 } 10218 10219 ipr_regs = pci_ioremap_bar(pdev, 0); 10220 10221 if (!ipr_regs) { 10222 dev_err(&pdev->dev, 10223 "Couldn't map memory range of registers\n"); 10224 rc = -ENOMEM; 10225 goto out_disable; 10226 } 10227 10228 ioa_cfg->hdw_dma_regs = ipr_regs; 10229 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci; 10230 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs; 10231 10232 ipr_init_regs(ioa_cfg); 10233 10234 if (ioa_cfg->sis64) { 10235 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64)); 10236 if (rc < 0) { 10237 dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n"); 10238 rc = dma_set_mask_and_coherent(&pdev->dev, 10239 DMA_BIT_MASK(32)); 10240 } 10241 } else 10242 rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32)); 10243 10244 if (rc < 0) { 10245 dev_err(&pdev->dev, "Failed to set DMA mask\n"); 10246 goto cleanup_nomem; 10247 } 10248 10249 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE, 10250 ioa_cfg->chip_cfg->cache_line_size); 10251 10252 if (rc != PCIBIOS_SUCCESSFUL) { 10253 dev_err(&pdev->dev, "Write of cache line size failed\n"); 10254 ipr_wait_for_pci_err_recovery(ioa_cfg); 10255 rc = -EIO; 10256 goto cleanup_nomem; 10257 } 10258 10259 /* Issue MMIO read to ensure card is not in EEH */ 10260 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg); 10261 ipr_wait_for_pci_err_recovery(ioa_cfg); 10262 10263 if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) { 10264 dev_err(&pdev->dev, "The max number of MSIX is %d\n", 10265 IPR_MAX_MSIX_VECTORS); 10266 ipr_number_of_msix = IPR_MAX_MSIX_VECTORS; 10267 } 10268 10269 irq_flag = PCI_IRQ_LEGACY; 10270 if (ioa_cfg->ipr_chip->has_msi) 10271 irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX; 10272 rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag); 10273 if (rc < 0) { 10274 ipr_wait_for_pci_err_recovery(ioa_cfg); 10275 goto cleanup_nomem; 10276 } 10277 ioa_cfg->nvectors = rc; 10278 10279 if (!pdev->msi_enabled && !pdev->msix_enabled) 10280 ioa_cfg->clear_isr = 1; 10281 10282 pci_set_master(pdev); 10283 10284 if (pci_channel_offline(pdev)) { 10285 ipr_wait_for_pci_err_recovery(ioa_cfg); 10286 pci_set_master(pdev); 10287 if (pci_channel_offline(pdev)) { 10288 rc = -EIO; 10289 goto out_msi_disable; 10290 } 10291 } 10292 10293 if (pdev->msi_enabled || pdev->msix_enabled) { 10294 rc = ipr_test_msi(ioa_cfg, pdev); 10295 switch (rc) { 10296 case 0: 10297 dev_info(&pdev->dev, 10298 "Request for %d MSI%ss succeeded.", ioa_cfg->nvectors, 10299 pdev->msix_enabled ? "-X" : ""); 10300 break; 10301 case -EOPNOTSUPP: 10302 ipr_wait_for_pci_err_recovery(ioa_cfg); 10303 pci_free_irq_vectors(pdev); 10304 10305 ioa_cfg->nvectors = 1; 10306 ioa_cfg->clear_isr = 1; 10307 break; 10308 default: 10309 goto out_msi_disable; 10310 } 10311 } 10312 10313 ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors, 10314 (unsigned int)num_online_cpus(), 10315 (unsigned int)IPR_MAX_HRRQ_NUM); 10316 10317 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg))) 10318 goto out_msi_disable; 10319 10320 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg))) 10321 goto out_msi_disable; 10322 10323 rc = ipr_alloc_mem(ioa_cfg); 10324 if (rc < 0) { 10325 dev_err(&pdev->dev, 10326 "Couldn't allocate enough memory for device driver!\n"); 10327 goto out_msi_disable; 10328 } 10329 10330 /* Save away PCI config space for use following IOA reset */ 10331 rc = pci_save_state(pdev); 10332 10333 if (rc != PCIBIOS_SUCCESSFUL) { 10334 dev_err(&pdev->dev, "Failed to save PCI config space\n"); 10335 rc = -EIO; 10336 goto cleanup_nolog; 10337 } 10338 10339 /* 10340 * If HRRQ updated interrupt is not masked, or reset alert is set, 10341 * the card is in an unknown state and needs a hard reset 10342 */ 10343 mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32); 10344 interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32); 10345 uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32); 10346 if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT)) 10347 ioa_cfg->needs_hard_reset = 1; 10348 if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices) 10349 ioa_cfg->needs_hard_reset = 1; 10350 if (interrupts & IPR_PCII_IOA_UNIT_CHECKED) 10351 ioa_cfg->ioa_unit_checked = 1; 10352 10353 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10354 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER); 10355 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10356 10357 if (pdev->msi_enabled || pdev->msix_enabled) { 10358 name_msi_vectors(ioa_cfg); 10359 rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0, 10360 ioa_cfg->vectors_info[0].desc, 10361 &ioa_cfg->hrrq[0]); 10362 if (!rc) 10363 rc = ipr_request_other_msi_irqs(ioa_cfg, pdev); 10364 } else { 10365 rc = request_irq(pdev->irq, ipr_isr, 10366 IRQF_SHARED, 10367 IPR_NAME, &ioa_cfg->hrrq[0]); 10368 } 10369 if (rc) { 10370 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n", 10371 pdev->irq, rc); 10372 goto cleanup_nolog; 10373 } 10374 10375 if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) || 10376 (dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) { 10377 ioa_cfg->needs_warm_reset = 1; 10378 ioa_cfg->reset = ipr_reset_slot_reset; 10379 10380 ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d", 10381 WQ_MEM_RECLAIM, host->host_no); 10382 10383 if (!ioa_cfg->reset_work_q) { 10384 dev_err(&pdev->dev, "Couldn't register reset workqueue\n"); 10385 rc = -ENOMEM; 10386 goto out_free_irq; 10387 } 10388 } else 10389 ioa_cfg->reset = ipr_reset_start_bist; 10390 10391 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags); 10392 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head); 10393 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags); 10394 10395 LEAVE; 10396 out: 10397 return rc; 10398 10399 out_free_irq: 10400 ipr_free_irqs(ioa_cfg); 10401 cleanup_nolog: 10402 ipr_free_mem(ioa_cfg); 10403 out_msi_disable: 10404 ipr_wait_for_pci_err_recovery(ioa_cfg); 10405 pci_free_irq_vectors(pdev); 10406 cleanup_nomem: 10407 iounmap(ipr_regs); 10408 out_disable: 10409 pci_disable_device(pdev); 10410 out_release_regions: 10411 pci_release_regions(pdev); 10412 out_scsi_host_put: 10413 scsi_host_put(host); 10414 goto out; 10415 } 10416 10417 /** 10418 * ipr_initiate_ioa_bringdown - Bring down an adapter 10419 * @ioa_cfg: ioa config struct 10420 * @shutdown_type: shutdown type 10421 * 10422 * Description: This function will initiate bringing down the adapter. 10423 * This consists of issuing an IOA shutdown to the adapter 10424 * to flush the cache, and running BIST. 10425 * If the caller needs to wait on the completion of the reset, 10426 * the caller must sleep on the reset_wait_q. 10427 * 10428 * Return value: 10429 * none 10430 **/ 10431 static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg, 10432 enum ipr_shutdown_type shutdown_type) 10433 { 10434 ENTER; 10435 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP) 10436 ioa_cfg->sdt_state = ABORT_DUMP; 10437 ioa_cfg->reset_retries = 0; 10438 ioa_cfg->in_ioa_bringdown = 1; 10439 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type); 10440 LEAVE; 10441 } 10442 10443 /** 10444 * __ipr_remove - Remove a single adapter 10445 * @pdev: pci device struct 10446 * 10447 * Adapter hot plug remove entry point. 10448 * 10449 * Return value: 10450 * none 10451 **/ 10452 static void __ipr_remove(struct pci_dev *pdev) 10453 { 10454 unsigned long host_lock_flags = 0; 10455 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 10456 int i; 10457 unsigned long driver_lock_flags; 10458 ENTER; 10459 10460 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags); 10461 while (ioa_cfg->in_reset_reload) { 10462 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags); 10463 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 10464 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags); 10465 } 10466 10467 for (i = 0; i < ioa_cfg->hrrq_num; i++) { 10468 spin_lock(&ioa_cfg->hrrq[i]._lock); 10469 ioa_cfg->hrrq[i].removing_ioa = 1; 10470 spin_unlock(&ioa_cfg->hrrq[i]._lock); 10471 } 10472 wmb(); 10473 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL); 10474 10475 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags); 10476 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 10477 flush_work(&ioa_cfg->work_q); 10478 if (ioa_cfg->reset_work_q) 10479 flush_workqueue(ioa_cfg->reset_work_q); 10480 INIT_LIST_HEAD(&ioa_cfg->used_res_q); 10481 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags); 10482 10483 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags); 10484 list_del(&ioa_cfg->queue); 10485 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags); 10486 10487 if (ioa_cfg->sdt_state == ABORT_DUMP) 10488 ioa_cfg->sdt_state = WAIT_FOR_DUMP; 10489 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags); 10490 10491 ipr_free_all_resources(ioa_cfg); 10492 10493 LEAVE; 10494 } 10495 10496 /** 10497 * ipr_remove - IOA hot plug remove entry point 10498 * @pdev: pci device struct 10499 * 10500 * Adapter hot plug remove entry point. 10501 * 10502 * Return value: 10503 * none 10504 **/ 10505 static void ipr_remove(struct pci_dev *pdev) 10506 { 10507 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 10508 10509 ENTER; 10510 10511 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj, 10512 &ipr_trace_attr); 10513 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj, 10514 &ipr_dump_attr); 10515 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj, 10516 &ipr_ioa_async_err_log); 10517 scsi_remove_host(ioa_cfg->host); 10518 10519 __ipr_remove(pdev); 10520 10521 LEAVE; 10522 } 10523 10524 /** 10525 * ipr_probe - Adapter hot plug add entry point 10526 * 10527 * Return value: 10528 * 0 on success / non-zero on failure 10529 **/ 10530 static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id) 10531 { 10532 struct ipr_ioa_cfg *ioa_cfg; 10533 unsigned long flags; 10534 int rc, i; 10535 10536 rc = ipr_probe_ioa(pdev, dev_id); 10537 10538 if (rc) 10539 return rc; 10540 10541 ioa_cfg = pci_get_drvdata(pdev); 10542 rc = ipr_probe_ioa_part2(ioa_cfg); 10543 10544 if (rc) { 10545 __ipr_remove(pdev); 10546 return rc; 10547 } 10548 10549 rc = scsi_add_host(ioa_cfg->host, &pdev->dev); 10550 10551 if (rc) { 10552 __ipr_remove(pdev); 10553 return rc; 10554 } 10555 10556 rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj, 10557 &ipr_trace_attr); 10558 10559 if (rc) { 10560 scsi_remove_host(ioa_cfg->host); 10561 __ipr_remove(pdev); 10562 return rc; 10563 } 10564 10565 rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj, 10566 &ipr_ioa_async_err_log); 10567 10568 if (rc) { 10569 ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj, 10570 &ipr_dump_attr); 10571 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj, 10572 &ipr_trace_attr); 10573 scsi_remove_host(ioa_cfg->host); 10574 __ipr_remove(pdev); 10575 return rc; 10576 } 10577 10578 rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj, 10579 &ipr_dump_attr); 10580 10581 if (rc) { 10582 sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj, 10583 &ipr_ioa_async_err_log); 10584 ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj, 10585 &ipr_trace_attr); 10586 scsi_remove_host(ioa_cfg->host); 10587 __ipr_remove(pdev); 10588 return rc; 10589 } 10590 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 10591 ioa_cfg->scan_enabled = 1; 10592 schedule_work(&ioa_cfg->work_q); 10593 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 10594 10595 ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight; 10596 10597 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) { 10598 for (i = 1; i < ioa_cfg->hrrq_num; i++) { 10599 irq_poll_init(&ioa_cfg->hrrq[i].iopoll, 10600 ioa_cfg->iopoll_weight, ipr_iopoll); 10601 } 10602 } 10603 10604 scsi_scan_host(ioa_cfg->host); 10605 10606 return 0; 10607 } 10608 10609 /** 10610 * ipr_shutdown - Shutdown handler. 10611 * @pdev: pci device struct 10612 * 10613 * This function is invoked upon system shutdown/reboot. It will issue 10614 * an adapter shutdown to the adapter to flush the write cache. 10615 * 10616 * Return value: 10617 * none 10618 **/ 10619 static void ipr_shutdown(struct pci_dev *pdev) 10620 { 10621 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev); 10622 unsigned long lock_flags = 0; 10623 enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL; 10624 int i; 10625 10626 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10627 if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) { 10628 ioa_cfg->iopoll_weight = 0; 10629 for (i = 1; i < ioa_cfg->hrrq_num; i++) 10630 irq_poll_disable(&ioa_cfg->hrrq[i].iopoll); 10631 } 10632 10633 while (ioa_cfg->in_reset_reload) { 10634 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10635 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 10636 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags); 10637 } 10638 10639 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) 10640 shutdown_type = IPR_SHUTDOWN_QUIESCE; 10641 10642 ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type); 10643 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags); 10644 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload); 10645 if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) { 10646 ipr_free_irqs(ioa_cfg); 10647 pci_disable_device(ioa_cfg->pdev); 10648 } 10649 } 10650 10651 static struct pci_device_id ipr_pci_table[] = { 10652 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, 10653 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 }, 10654 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, 10655 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 }, 10656 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, 10657 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 }, 10658 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, 10659 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 }, 10660 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, 10661 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 }, 10662 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, 10663 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 }, 10664 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, 10665 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 }, 10666 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, 10667 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0, 10668 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10669 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, 10670 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 }, 10671 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, 10672 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 10673 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10674 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, 10675 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0, 10676 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10677 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, 10678 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 }, 10679 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, 10680 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 10681 IPR_USE_LONG_TRANSOP_TIMEOUT}, 10682 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, 10683 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0, 10684 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10685 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, 10686 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0, 10687 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10688 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, 10689 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 }, 10690 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, 10691 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 }, 10692 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, 10693 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0, 10694 IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET }, 10695 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, 10696 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 }, 10697 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, 10698 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 }, 10699 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, 10700 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0, 10701 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10702 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, 10703 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0, 10704 IPR_USE_LONG_TRANSOP_TIMEOUT }, 10705 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10706 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 }, 10707 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10708 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 }, 10709 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10710 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 }, 10711 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10712 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 }, 10713 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10714 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 }, 10715 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, 10716 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 }, 10717 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10718 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 }, 10719 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10720 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 }, 10721 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10722 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 }, 10723 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10724 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 }, 10725 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10726 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 }, 10727 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10728 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 }, 10729 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10730 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 }, 10731 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10732 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 }, 10733 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10734 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 }, 10735 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10736 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 }, 10737 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10738 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 }, 10739 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10740 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 }, 10741 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10742 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 }, 10743 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10744 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 }, 10745 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10746 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 }, 10747 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10748 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 }, 10749 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10750 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 }, 10751 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10752 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 }, 10753 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10754 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 }, 10755 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, 10756 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 }, 10757 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE, 10758 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 }, 10759 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE, 10760 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 }, 10761 { } 10762 }; 10763 MODULE_DEVICE_TABLE(pci, ipr_pci_table); 10764 10765 static const struct pci_error_handlers ipr_err_handler = { 10766 .error_detected = ipr_pci_error_detected, 10767 .mmio_enabled = ipr_pci_mmio_enabled, 10768 .slot_reset = ipr_pci_slot_reset, 10769 }; 10770 10771 static struct pci_driver ipr_driver = { 10772 .name = IPR_NAME, 10773 .id_table = ipr_pci_table, 10774 .probe = ipr_probe, 10775 .remove = ipr_remove, 10776 .shutdown = ipr_shutdown, 10777 .err_handler = &ipr_err_handler, 10778 }; 10779 10780 /** 10781 * ipr_halt_done - Shutdown prepare completion 10782 * 10783 * Return value: 10784 * none 10785 **/ 10786 static void ipr_halt_done(struct ipr_cmnd *ipr_cmd) 10787 { 10788 list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q); 10789 } 10790 10791 /** 10792 * ipr_halt - Issue shutdown prepare to all adapters 10793 * 10794 * Return value: 10795 * NOTIFY_OK on success / NOTIFY_DONE on failure 10796 **/ 10797 static int ipr_halt(struct notifier_block *nb, ulong event, void *buf) 10798 { 10799 struct ipr_cmnd *ipr_cmd; 10800 struct ipr_ioa_cfg *ioa_cfg; 10801 unsigned long flags = 0, driver_lock_flags; 10802 10803 if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF) 10804 return NOTIFY_DONE; 10805 10806 spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags); 10807 10808 list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) { 10809 spin_lock_irqsave(ioa_cfg->host->host_lock, flags); 10810 if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds || 10811 (ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) { 10812 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 10813 continue; 10814 } 10815 10816 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg); 10817 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE); 10818 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD; 10819 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN; 10820 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL; 10821 10822 ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT); 10823 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags); 10824 } 10825 spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags); 10826 10827 return NOTIFY_OK; 10828 } 10829 10830 static struct notifier_block ipr_notifier = { 10831 ipr_halt, NULL, 0 10832 }; 10833 10834 /** 10835 * ipr_init - Module entry point 10836 * 10837 * Return value: 10838 * 0 on success / negative value on failure 10839 **/ 10840 static int __init ipr_init(void) 10841 { 10842 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n", 10843 IPR_DRIVER_VERSION, IPR_DRIVER_DATE); 10844 10845 register_reboot_notifier(&ipr_notifier); 10846 return pci_register_driver(&ipr_driver); 10847 } 10848 10849 /** 10850 * ipr_exit - Module unload 10851 * 10852 * Module unload entry point. 10853 * 10854 * Return value: 10855 * none 10856 **/ 10857 static void __exit ipr_exit(void) 10858 { 10859 unregister_reboot_notifier(&ipr_notifier); 10860 pci_unregister_driver(&ipr_driver); 10861 } 10862 10863 module_init(ipr_init); 10864 module_exit(ipr_exit); 10865