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