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