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