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