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