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