]> git.proxmox.com Git - mirror_ubuntu-zesty-kernel.git/blame - drivers/scsi/ipr.c
projects / mirror_ubuntu-zesty-kernel.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
[SCSI] ipr: Handle UA on disk array following an adapter reset
[mirror_ubuntu-zesty-kernel.git] / drivers / scsi / ipr.c
CommitLineData
1da177e4
LT		 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
1da177e4
LT		 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/ioport.h>
63#include <linux/delay.h>
64#include <linux/pci.h>
65#include <linux/wait.h>
66#include <linux/spinlock.h>
67#include <linux/sched.h>
68#include <linux/interrupt.h>
69#include <linux/blkdev.h>
70#include <linux/firmware.h>
71#include <linux/module.h>
72#include <linux/moduleparam.h>
35a39691 73#include <linux/libata.h>
1da177e4
LT		 74#include <asm/io.h>
75#include <asm/irq.h>
76#include <asm/processor.h>
77#include <scsi/scsi.h>
78#include <scsi/scsi_host.h>
79#include <scsi/scsi_tcq.h>
80#include <scsi/scsi_eh.h>
81#include <scsi/scsi_cmnd.h>
1da177e4
LT		 82#include "ipr.h"
83
84/*
85 * Global Data
86 */
87static struct list_head ipr_ioa_head = LIST_HEAD_INIT(ipr_ioa_head);
88static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
89static unsigned int ipr_max_speed = 1;
90static int ipr_testmode = 0;
91static unsigned int ipr_fastfail = 0;
5469cb5b 92static unsigned int ipr_transop_timeout = 0;
62275040 93static unsigned int ipr_enable_cache = 1;
d3c74871 94static unsigned int ipr_debug = 0;
1da177e4
LT		 95static DEFINE_SPINLOCK(ipr_driver_lock);
96
97/* This table describes the differences between DMA controller chips */
98static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
60e7486b 99 { /* Gemstone, Citrine, Obsidian, and Obsidian-E */
1da177e4
LT		 100 .mailbox = 0x0042C,
101 .cache_line_size = 0x20,
102 {
103 .set_interrupt_mask_reg = 0x0022C,
104 .clr_interrupt_mask_reg = 0x00230,
105 .sense_interrupt_mask_reg = 0x0022C,
106 .clr_interrupt_reg = 0x00228,
107 .sense_interrupt_reg = 0x00224,
108 .ioarrin_reg = 0x00404,
109 .sense_uproc_interrupt_reg = 0x00214,
110 .set_uproc_interrupt_reg = 0x00214,
111 .clr_uproc_interrupt_reg = 0x00218
112 }
113 },
114 { /* Snipe and Scamp */
115 .mailbox = 0x0052C,
116 .cache_line_size = 0x20,
117 {
118 .set_interrupt_mask_reg = 0x00288,
119 .clr_interrupt_mask_reg = 0x0028C,
120 .sense_interrupt_mask_reg = 0x00288,
121 .clr_interrupt_reg = 0x00284,
122 .sense_interrupt_reg = 0x00280,
123 .ioarrin_reg = 0x00504,
124 .sense_uproc_interrupt_reg = 0x00290,
125 .set_uproc_interrupt_reg = 0x00290,
126 .clr_uproc_interrupt_reg = 0x00294
127 }
128 },
129};
130
131static const struct ipr_chip_t ipr_chip[] = {
132 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, &ipr_chip_cfg[0] },
133 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, &ipr_chip_cfg[0] },
86f51436
BK		 134 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, &ipr_chip_cfg[0] },
135 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, &ipr_chip_cfg[0] },
60e7486b 136 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, &ipr_chip_cfg[0] },
1da177e4
LT		 137 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, &ipr_chip_cfg[1] },
138 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, &ipr_chip_cfg[1] }
139};
140
141static int ipr_max_bus_speeds [] = {
142 IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
143};
144
145MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
146MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
147module_param_named(max_speed, ipr_max_speed, uint, 0);
148MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
149module_param_named(log_level, ipr_log_level, uint, 0);
150MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
151module_param_named(testmode, ipr_testmode, int, 0);
152MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
153module_param_named(fastfail, ipr_fastfail, int, 0);
154MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
155module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
156MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
62275040
BK		 157module_param_named(enable_cache, ipr_enable_cache, int, 0);
158MODULE_PARM_DESC(enable_cache, "Enable adapter's non-volatile write cache (default: 1)");
d3c74871
BK		 159module_param_named(debug, ipr_debug, int, 0);
160MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
1da177e4
LT		 161MODULE_LICENSE("GPL");
162MODULE_VERSION(IPR_DRIVER_VERSION);
163
1da177e4
LT		 164/* A constant array of IOASCs/URCs/Error Messages */
165static const
166struct ipr_error_table_t ipr_error_table[] = {
933916f3 167 {0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 168 "8155: An unknown error was received"},
169 {0x00330000, 0, 0,
170 "Soft underlength error"},
171 {0x005A0000, 0, 0,
172 "Command to be cancelled not found"},
173 {0x00808000, 0, 0,
174 "Qualified success"},
933916f3 175 {0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 176 "FFFE: Soft device bus error recovered by the IOA"},
933916f3 177 {0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 178 "4101: Soft device bus fabric error"},
933916f3 179 {0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 180 "FFF9: Device sector reassign successful"},
933916f3 181 {0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 182 "FFF7: Media error recovered by device rewrite procedures"},
933916f3 183 {0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 184 "7001: IOA sector reassignment successful"},
933916f3 185 {0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 186 "FFF9: Soft media error. Sector reassignment recommended"},
933916f3 187 {0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 188 "FFF7: Media error recovered by IOA rewrite procedures"},
933916f3 189 {0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 190 "FF3D: Soft PCI bus error recovered by the IOA"},
933916f3 191 {0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 192 "FFF6: Device hardware error recovered by the IOA"},
933916f3 193 {0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 194 "FFF6: Device hardware error recovered by the device"},
933916f3 195 {0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 196 "FF3D: Soft IOA error recovered by the IOA"},
933916f3 197 {0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 198 "FFFA: Undefined device response recovered by the IOA"},
933916f3 199 {0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 200 "FFF6: Device bus error, message or command phase"},
933916f3 201 {0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
35a39691 202 "FFFE: Task Management Function failed"},
933916f3 203 {0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 204 "FFF6: Failure prediction threshold exceeded"},
933916f3 205 {0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 206 "8009: Impending cache battery pack failure"},
207 {0x02040400, 0, 0,
208 "34FF: Disk device format in progress"},
209 {0x023F0000, 0, 0,
210 "Synchronization required"},
211 {0x024E0000, 0, 0,
212 "No ready, IOA shutdown"},
213 {0x025A0000, 0, 0,
214 "Not ready, IOA has been shutdown"},
933916f3 215 {0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 216 "3020: Storage subsystem configuration error"},
217 {0x03110B00, 0, 0,
218 "FFF5: Medium error, data unreadable, recommend reassign"},
219 {0x03110C00, 0, 0,
220 "7000: Medium error, data unreadable, do not reassign"},
933916f3 221 {0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 222 "FFF3: Disk media format bad"},
933916f3 223 {0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 224 "3002: Addressed device failed to respond to selection"},
933916f3 225 {0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 226 "3100: Device bus error"},
933916f3 227 {0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 228 "3109: IOA timed out a device command"},
229 {0x04088000, 0, 0,
230 "3120: SCSI bus is not operational"},
933916f3 231 {0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 232 "4100: Hard device bus fabric error"},
933916f3 233 {0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 234 "9000: IOA reserved area data check"},
933916f3 235 {0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 236 "9001: IOA reserved area invalid data pattern"},
933916f3 237 {0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 238 "9002: IOA reserved area LRC error"},
933916f3 239 {0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 240 "102E: Out of alternate sectors for disk storage"},
933916f3 241 {0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 242 "FFF4: Data transfer underlength error"},
933916f3 243 {0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 244 "FFF4: Data transfer overlength error"},
933916f3 245 {0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 246 "3400: Logical unit failure"},
933916f3 247 {0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 248 "FFF4: Device microcode is corrupt"},
933916f3 249 {0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 250 "8150: PCI bus error"},
251 {0x04430000, 1, 0,
252 "Unsupported device bus message received"},
933916f3 253 {0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 254 "FFF4: Disk device problem"},
933916f3 255 {0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 256 "8150: Permanent IOA failure"},
933916f3 257 {0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 258 "3010: Disk device returned wrong response to IOA"},
933916f3 259 {0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 260 "8151: IOA microcode error"},
261 {0x04448500, 0, 0,
262 "Device bus status error"},
933916f3 263 {0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 264 "8157: IOA error requiring IOA reset to recover"},
35a39691
BK		 265 {0x04448700, 0, 0,
266 "ATA device status error"},
1da177e4
LT		 267 {0x04490000, 0, 0,
268 "Message reject received from the device"},
933916f3 269 {0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 270 "8008: A permanent cache battery pack failure occurred"},
933916f3 271 {0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 272 "9090: Disk unit has been modified after the last known status"},
933916f3 273 {0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 274 "9081: IOA detected device error"},
933916f3 275 {0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 276 "9082: IOA detected device error"},
933916f3 277 {0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
1da177e4 278 "3110: Device bus error, message or command phase"},
933916f3 279 {0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
35a39691 280 "3110: SAS Command / Task Management Function failed"},
933916f3 281 {0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 282 "9091: Incorrect hardware configuration change has been detected"},
933916f3 283 {0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
b0df54bb 284 "9073: Invalid multi-adapter configuration"},
933916f3 285 {0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 286 "4010: Incorrect connection between cascaded expanders"},
933916f3 287 {0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 288 "4020: Connections exceed IOA design limits"},
933916f3 289 {0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 290 "4030: Incorrect multipath connection"},
933916f3 291 {0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 292 "4110: Unsupported enclosure function"},
933916f3 293 {0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 294 "FFF4: Command to logical unit failed"},
295 {0x05240000, 1, 0,
296 "Illegal request, invalid request type or request packet"},
297 {0x05250000, 0, 0,
298 "Illegal request, invalid resource handle"},
b0df54bb
BK		 299 {0x05258000, 0, 0,
300 "Illegal request, commands not allowed to this device"},
301 {0x05258100, 0, 0,
302 "Illegal request, command not allowed to a secondary adapter"},
1da177e4
LT		 303 {0x05260000, 0, 0,
304 "Illegal request, invalid field in parameter list"},
305 {0x05260100, 0, 0,
306 "Illegal request, parameter not supported"},
307 {0x05260200, 0, 0,
308 "Illegal request, parameter value invalid"},
309 {0x052C0000, 0, 0,
310 "Illegal request, command sequence error"},
b0df54bb
BK		 311 {0x052C8000, 1, 0,
312 "Illegal request, dual adapter support not enabled"},
933916f3 313 {0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 314 "9031: Array protection temporarily suspended, protection resuming"},
933916f3 315 {0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 316 "9040: Array protection temporarily suspended, protection resuming"},
933916f3 317 {0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 318 "3140: Device bus not ready to ready transition"},
933916f3 319 {0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 320 "FFFB: SCSI bus was reset"},
321 {0x06290500, 0, 0,
322 "FFFE: SCSI bus transition to single ended"},
323 {0x06290600, 0, 0,
324 "FFFE: SCSI bus transition to LVD"},
933916f3 325 {0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 326 "FFFB: SCSI bus was reset by another initiator"},
933916f3 327 {0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 328 "3029: A device replacement has occurred"},
933916f3 329 {0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 330 "9051: IOA cache data exists for a missing or failed device"},
933916f3 331 {0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
b0df54bb 332 "9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
933916f3 333 {0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 334 "9025: Disk unit is not supported at its physical location"},
933916f3 335 {0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 336 "3020: IOA detected a SCSI bus configuration error"},
933916f3 337 {0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 338 "3150: SCSI bus configuration error"},
933916f3 339 {0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
b0df54bb 340 "9074: Asymmetric advanced function disk configuration"},
933916f3 341 {0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 342 "4040: Incomplete multipath connection between IOA and enclosure"},
933916f3 343 {0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 344 "4041: Incomplete multipath connection between enclosure and device"},
933916f3 345 {0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 346 "9075: Incomplete multipath connection between IOA and remote IOA"},
933916f3 347 {0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 348 "9076: Configuration error, missing remote IOA"},
933916f3 349 {0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 350 "4050: Enclosure does not support a required multipath function"},
933916f3 351 {0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 352 "9041: Array protection temporarily suspended"},
933916f3 353 {0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 354 "9042: Corrupt array parity detected on specified device"},
933916f3 355 {0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 356 "9030: Array no longer protected due to missing or failed disk unit"},
933916f3 357 {0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
b0df54bb 358 "9071: Link operational transition"},
933916f3 359 {0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
b0df54bb 360 "9072: Link not operational transition"},
933916f3 361 {0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 362 "9032: Array exposed but still protected"},
e435340c
BK		 363 {0x066B8300, 0, IPR_DEFAULT_LOG_LEVEL + 1,
364 "70DD: Device forced failed by disrupt device command"},
933916f3 365 {0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 366 "4061: Multipath redundancy level got better"},
933916f3 367 {0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
896bbd21 368 "4060: Multipath redundancy level got worse"},
1da177e4
LT		 369 {0x07270000, 0, 0,
370 "Failure due to other device"},
933916f3 371 {0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 372 "9008: IOA does not support functions expected by devices"},
933916f3 373 {0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 374 "9010: Cache data associated with attached devices cannot be found"},
933916f3 375 {0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 376 "9011: Cache data belongs to devices other than those attached"},
933916f3 377 {0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 378 "9020: Array missing 2 or more devices with only 1 device present"},
933916f3 379 {0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 380 "9021: Array missing 2 or more devices with 2 or more devices present"},
933916f3 381 {0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 382 "9022: Exposed array is missing a required device"},
933916f3 383 {0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 384 "9023: Array member(s) not at required physical locations"},
933916f3 385 {0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 386 "9024: Array not functional due to present hardware configuration"},
933916f3 387 {0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 388 "9026: Array not functional due to present hardware configuration"},
933916f3 389 {0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 390 "9027: Array is missing a device and parity is out of sync"},
933916f3 391 {0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 392 "9028: Maximum number of arrays already exist"},
933916f3 393 {0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 394 "9050: Required cache data cannot be located for a disk unit"},
933916f3 395 {0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 396 "9052: Cache data exists for a device that has been modified"},
933916f3 397 {0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 398 "9054: IOA resources not available due to previous problems"},
933916f3 399 {0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 400 "9092: Disk unit requires initialization before use"},
933916f3 401 {0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 402 "9029: Incorrect hardware configuration change has been detected"},
933916f3 403 {0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 404 "9060: One or more disk pairs are missing from an array"},
933916f3 405 {0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 406 "9061: One or more disks are missing from an array"},
933916f3 407 {0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4 408 "9062: One or more disks are missing from an array"},
933916f3 409 {0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
1da177e4
LT		 410 "9063: Maximum number of functional arrays has been exceeded"},
411 {0x0B260000, 0, 0,
412 "Aborted command, invalid descriptor"},
413 {0x0B5A0000, 0, 0,
414 "Command terminated by host"}
415};
416
417static const struct ipr_ses_table_entry ipr_ses_table[] = {
418 { "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
419 { "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
420 { "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
421 { "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
422 { "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
423 { "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
424 { "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
425 { "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
426 { "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
427 { "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
428 { "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
429 { "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
430 { "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
431};
432
433/*
434 * Function Prototypes
435 */
436static int ipr_reset_alert(struct ipr_cmnd *);
437static void ipr_process_ccn(struct ipr_cmnd *);
438static void ipr_process_error(struct ipr_cmnd *);
439static void ipr_reset_ioa_job(struct ipr_cmnd *);
440static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
441 enum ipr_shutdown_type);
442
443#ifdef CONFIG_SCSI_IPR_TRACE
444/**
445 * ipr_trc_hook - Add a trace entry to the driver trace
446 * @ipr_cmd: ipr command struct
447 * @type: trace type
448 * @add_data: additional data
449 *
450 * Return value:
451 * none
452 **/
453static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
454 u8 type, u32 add_data)
455{
456 struct ipr_trace_entry *trace_entry;
457 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
458
459 trace_entry = &ioa_cfg->trace[ioa_cfg->trace_index++];
460 trace_entry->time = jiffies;
461 trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
462 trace_entry->type = type;
35a39691
BK		 463 trace_entry->ata_op_code = ipr_cmd->ioarcb.add_data.u.regs.command;
464 trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
1da177e4
LT		 465 trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
466 trace_entry->u.add_data = add_data;
467}
468#else
469#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while(0)
470#endif
471
472/**
473 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
474 * @ipr_cmd: ipr command struct
475 *
476 * Return value:
477 * none
478 **/
479static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
480{
481 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
482 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
51b1c7e1 483 dma_addr_t dma_addr = be32_to_cpu(ioarcb->ioarcb_host_pci_addr);
1da177e4
LT		 484
485 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
486 ioarcb->write_data_transfer_length = 0;
487 ioarcb->read_data_transfer_length = 0;
488 ioarcb->write_ioadl_len = 0;
489 ioarcb->read_ioadl_len = 0;
51b1c7e1
BK		 490 ioarcb->write_ioadl_addr =
491 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
492 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
1da177e4
LT		 493 ioasa->ioasc = 0;
494 ioasa->residual_data_len = 0;
35a39691 495 ioasa->u.gata.status = 0;
1da177e4
LT		 496
497 ipr_cmd->scsi_cmd = NULL;
35a39691 498 ipr_cmd->qc = NULL;
1da177e4
LT		 499 ipr_cmd->sense_buffer[0] = 0;
500 ipr_cmd->dma_use_sg = 0;
501}
502
503/**
504 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
505 * @ipr_cmd: ipr command struct
506 *
507 * Return value:
508 * none
509 **/
510static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
511{
512 ipr_reinit_ipr_cmnd(ipr_cmd);
513 ipr_cmd->u.scratch = 0;
514 ipr_cmd->sibling = NULL;
515 init_timer(&ipr_cmd->timer);
516}
517
518/**
519 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
520 * @ioa_cfg: ioa config struct
521 *
522 * Return value:
523 * pointer to ipr command struct
524 **/
525static
526struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
527{
528 struct ipr_cmnd *ipr_cmd;
529
530 ipr_cmd = list_entry(ioa_cfg->free_q.next, struct ipr_cmnd, queue);
531 list_del(&ipr_cmd->queue);
532 ipr_init_ipr_cmnd(ipr_cmd);
533
534 return ipr_cmd;
535}
536
537/**
538 * ipr_unmap_sglist - Unmap scatterlist if mapped
539 * @ioa_cfg: ioa config struct
540 * @ipr_cmd: ipr command struct
541 *
542 * Return value:
543 * nothing
544 **/
545static void ipr_unmap_sglist(struct ipr_ioa_cfg *ioa_cfg,
546 struct ipr_cmnd *ipr_cmd)
547{
548 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
549
550 if (ipr_cmd->dma_use_sg) {
551 if (scsi_cmd->use_sg > 0) {
552 pci_unmap_sg(ioa_cfg->pdev, scsi_cmd->request_buffer,
553 scsi_cmd->use_sg,
554 scsi_cmd->sc_data_direction);
555 } else {
556 pci_unmap_single(ioa_cfg->pdev, ipr_cmd->dma_handle,
557 scsi_cmd->request_bufflen,
558 scsi_cmd->sc_data_direction);
559 }
560 }
561}
562
563/**
564 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
565 * @ioa_cfg: ioa config struct
566 * @clr_ints: interrupts to clear
567 *
568 * This function masks all interrupts on the adapter, then clears the
569 * interrupts specified in the mask
570 *
571 * Return value:
572 * none
573 **/
574static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
575 u32 clr_ints)
576{
577 volatile u32 int_reg;
578
579 /* Stop new interrupts */
580 ioa_cfg->allow_interrupts = 0;
581
582 /* Set interrupt mask to stop all new interrupts */
583 writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
584
585 /* Clear any pending interrupts */
586 writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg);
587 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
588}
589
590/**
591 * ipr_save_pcix_cmd_reg - Save PCI-X command register
592 * @ioa_cfg: ioa config struct
593 *
594 * Return value:
595 * 0 on success / -EIO on failure
596 **/
597static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
598{
599 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
600
7dce0e1c
BK		 601 if (pcix_cmd_reg == 0)
602 return 0;
1da177e4
LT		 603
604 if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
605 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
606 dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
607 return -EIO;
608 }
609
610 ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
611 return 0;
612}
613
614/**
615 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
616 * @ioa_cfg: ioa config struct
617 *
618 * Return value:
619 * 0 on success / -EIO on failure
620 **/
621static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
622{
623 int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
624
625 if (pcix_cmd_reg) {
626 if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
627 ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
628 dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
629 return -EIO;
630 }
1da177e4
LT		 631 }
632
633 return 0;
634}
635
35a39691
BK		 636/**
637 * ipr_sata_eh_done - done function for aborted SATA commands
638 * @ipr_cmd: ipr command struct
639 *
640 * This function is invoked for ops generated to SATA
641 * devices which are being aborted.
642 *
643 * Return value:
644 * none
645 **/
646static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
647{
648 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
649 struct ata_queued_cmd *qc = ipr_cmd->qc;
650 struct ipr_sata_port *sata_port = qc->ap->private_data;
651
652 qc->err_mask |= AC_ERR_OTHER;
653 sata_port->ioasa.status |= ATA_BUSY;
654 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
655 ata_qc_complete(qc);
656}
657
1da177e4
LT		 658/**
659 * ipr_scsi_eh_done - mid-layer done function for aborted ops
660 * @ipr_cmd: ipr command struct
661 *
662 * This function is invoked by the interrupt handler for
663 * ops generated by the SCSI mid-layer which are being aborted.
664 *
665 * Return value:
666 * none
667 **/
668static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
669{
670 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
671 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
672
673 scsi_cmd->result |= (DID_ERROR << 16);
674
675 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
676 scsi_cmd->scsi_done(scsi_cmd);
677 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
678}
679
680/**
681 * ipr_fail_all_ops - Fails all outstanding ops.
682 * @ioa_cfg: ioa config struct
683 *
684 * This function fails all outstanding ops.
685 *
686 * Return value:
687 * none
688 **/
689static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
690{
691 struct ipr_cmnd *ipr_cmd, *temp;
692
693 ENTER;
694 list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
695 list_del(&ipr_cmd->queue);
696
697 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
698 ipr_cmd->ioasa.ilid = cpu_to_be32(IPR_DRIVER_ILID);
699
700 if (ipr_cmd->scsi_cmd)
701 ipr_cmd->done = ipr_scsi_eh_done;
35a39691
BK		 702 else if (ipr_cmd->qc)
703 ipr_cmd->done = ipr_sata_eh_done;
1da177e4
LT		 704
705 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, IPR_IOASC_IOA_WAS_RESET);
706 del_timer(&ipr_cmd->timer);
707 ipr_cmd->done(ipr_cmd);
708 }
709
710 LEAVE;
711}
712
713/**
714 * ipr_do_req - Send driver initiated requests.
715 * @ipr_cmd: ipr command struct
716 * @done: done function
717 * @timeout_func: timeout function
718 * @timeout: timeout value
719 *
720 * This function sends the specified command to the adapter with the
721 * timeout given. The done function is invoked on command completion.
722 *
723 * Return value:
724 * none
725 **/
726static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
727 void (*done) (struct ipr_cmnd *),
728 void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
729{
730 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
731
732 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
733
734 ipr_cmd->done = done;
735
736 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
737 ipr_cmd->timer.expires = jiffies + timeout;
738 ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
739
740 add_timer(&ipr_cmd->timer);
741
742 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
743
744 mb();
745 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
746 ioa_cfg->regs.ioarrin_reg);
747}
748
749/**
750 * ipr_internal_cmd_done - Op done function for an internally generated op.
751 * @ipr_cmd: ipr command struct
752 *
753 * This function is the op done function for an internally generated,
754 * blocking op. It simply wakes the sleeping thread.
755 *
756 * Return value:
757 * none
758 **/
759static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
760{
761 if (ipr_cmd->sibling)
762 ipr_cmd->sibling = NULL;
763 else
764 complete(&ipr_cmd->completion);
765}
766
767/**
768 * ipr_send_blocking_cmd - Send command and sleep on its completion.
769 * @ipr_cmd: ipr command struct
770 * @timeout_func: function to invoke if command times out
771 * @timeout: timeout
772 *
773 * Return value:
774 * none
775 **/
776static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
777 void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
778 u32 timeout)
779{
780 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
781
782 init_completion(&ipr_cmd->completion);
783 ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
784
785 spin_unlock_irq(ioa_cfg->host->host_lock);
786 wait_for_completion(&ipr_cmd->completion);
787 spin_lock_irq(ioa_cfg->host->host_lock);
788}
789
790/**
791 * ipr_send_hcam - Send an HCAM to the adapter.
792 * @ioa_cfg: ioa config struct
793 * @type: HCAM type
794 * @hostrcb: hostrcb struct
795 *
796 * This function will send a Host Controlled Async command to the adapter.
797 * If HCAMs are currently not allowed to be issued to the adapter, it will
798 * place the hostrcb on the free queue.
799 *
800 * Return value:
801 * none
802 **/
803static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
804 struct ipr_hostrcb *hostrcb)
805{
806 struct ipr_cmnd *ipr_cmd;
807 struct ipr_ioarcb *ioarcb;
808
809 if (ioa_cfg->allow_cmds) {
810 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
811 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
812 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
813
814 ipr_cmd->u.hostrcb = hostrcb;
815 ioarcb = &ipr_cmd->ioarcb;
816
817 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
818 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
819 ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
820 ioarcb->cmd_pkt.cdb[1] = type;
821 ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
822 ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
823
824 ioarcb->read_data_transfer_length = cpu_to_be32(sizeof(hostrcb->hcam));
825 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
826 ipr_cmd->ioadl[0].flags_and_data_len =
827 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(hostrcb->hcam));
828 ipr_cmd->ioadl[0].address = cpu_to_be32(hostrcb->hostrcb_dma);
829
830 if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
831 ipr_cmd->done = ipr_process_ccn;
832 else
833 ipr_cmd->done = ipr_process_error;
834
835 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
836
837 mb();
838 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
839 ioa_cfg->regs.ioarrin_reg);
840 } else {
841 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
842 }
843}
844
845/**
846 * ipr_init_res_entry - Initialize a resource entry struct.
847 * @res: resource entry struct
848 *
849 * Return value:
850 * none
851 **/
852static void ipr_init_res_entry(struct ipr_resource_entry *res)
853{
ee0a90fa 854 res->needs_sync_complete = 0;
1da177e4
LT		 855 res->in_erp = 0;
856 res->add_to_ml = 0;
857 res->del_from_ml = 0;
858 res->resetting_device = 0;
859 res->sdev = NULL;
35a39691 860 res->sata_port = NULL;
1da177e4
LT		 861}
862
863/**
864 * ipr_handle_config_change - Handle a config change from the adapter
865 * @ioa_cfg: ioa config struct
866 * @hostrcb: hostrcb
867 *
868 * Return value:
869 * none
870 **/
871static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
872 struct ipr_hostrcb *hostrcb)
873{
874 struct ipr_resource_entry *res = NULL;
875 struct ipr_config_table_entry *cfgte;
876 u32 is_ndn = 1;
877
878 cfgte = &hostrcb->hcam.u.ccn.cfgte;
879
880 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
881 if (!memcmp(&res->cfgte.res_addr, &cfgte->res_addr,
882 sizeof(cfgte->res_addr))) {
883 is_ndn = 0;
884 break;
885 }
886 }
887
888 if (is_ndn) {
889 if (list_empty(&ioa_cfg->free_res_q)) {
890 ipr_send_hcam(ioa_cfg,
891 IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
892 hostrcb);
893 return;
894 }
895
896 res = list_entry(ioa_cfg->free_res_q.next,
897 struct ipr_resource_entry, queue);
898
899 list_del(&res->queue);
900 ipr_init_res_entry(res);
901 list_add_tail(&res->queue, &ioa_cfg->used_res_q);
902 }
903
904 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
905
906 if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
907 if (res->sdev) {
1da177e4 908 res->del_from_ml = 1;
1121b794 909 res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
1da177e4
LT		 910 if (ioa_cfg->allow_ml_add_del)
911 schedule_work(&ioa_cfg->work_q);
912 } else
913 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
914 } else if (!res->sdev) {
915 res->add_to_ml = 1;
916 if (ioa_cfg->allow_ml_add_del)
917 schedule_work(&ioa_cfg->work_q);
918 }
919
920 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
921}
922
923/**
924 * ipr_process_ccn - Op done function for a CCN.
925 * @ipr_cmd: ipr command struct
926 *
927 * This function is the op done function for a configuration
928 * change notification host controlled async from the adapter.
929 *
930 * Return value:
931 * none
932 **/
933static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
934{
935 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
936 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
937 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
938
939 list_del(&hostrcb->queue);
940 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
941
942 if (ioasc) {
943 if (ioasc != IPR_IOASC_IOA_WAS_RESET)
944 dev_err(&ioa_cfg->pdev->dev,
945 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
946
947 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
948 } else {
949 ipr_handle_config_change(ioa_cfg, hostrcb);
950 }
951}
952
953/**
954 * ipr_log_vpd - Log the passed VPD to the error log.
cfc32139 955 * @vpd: vendor/product id/sn struct
1da177e4
LT		 956 *
957 * Return value:
958 * none
959 **/
cfc32139 960static void ipr_log_vpd(struct ipr_vpd *vpd)
1da177e4
LT		 961{
962 char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
963 + IPR_SERIAL_NUM_LEN];
964
cfc32139
BK		 965 memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
966 memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1da177e4
LT		 967 IPR_PROD_ID_LEN);
968 buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
969 ipr_err("Vendor/Product ID: %s\n", buffer);
970
cfc32139 971 memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1da177e4
LT		 972 buffer[IPR_SERIAL_NUM_LEN] = '\0';
973 ipr_err(" Serial Number: %s\n", buffer);
974}
975
ee0f05b8
BK		 976/**
977 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
978 * @vpd: vendor/product id/sn/wwn struct
979 *
980 * Return value:
981 * none
982 **/
983static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
984{
985 ipr_log_vpd(&vpd->vpd);
986 ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
987 be32_to_cpu(vpd->wwid[1]));
988}
989
990/**
991 * ipr_log_enhanced_cache_error - Log a cache error.
992 * @ioa_cfg: ioa config struct
993 * @hostrcb: hostrcb struct
994 *
995 * Return value:
996 * none
997 **/
998static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
999 struct ipr_hostrcb *hostrcb)
1000{
1001 struct ipr_hostrcb_type_12_error *error =
1002 &hostrcb->hcam.u.error.u.type_12_error;
1003
1004 ipr_err("-----Current Configuration-----\n");
1005 ipr_err("Cache Directory Card Information:\n");
1006 ipr_log_ext_vpd(&error->ioa_vpd);
1007 ipr_err("Adapter Card Information:\n");
1008 ipr_log_ext_vpd(&error->cfc_vpd);
1009
1010 ipr_err("-----Expected Configuration-----\n");
1011 ipr_err("Cache Directory Card Information:\n");
1012 ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1013 ipr_err("Adapter Card Information:\n");
1014 ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1015
1016 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1017 be32_to_cpu(error->ioa_data[0]),
1018 be32_to_cpu(error->ioa_data[1]),
1019 be32_to_cpu(error->ioa_data[2]));
1020}
1021
1da177e4
LT		 1022/**
1023 * ipr_log_cache_error - Log a cache error.
1024 * @ioa_cfg: ioa config struct
1025 * @hostrcb: hostrcb struct
1026 *
1027 * Return value:
1028 * none
1029 **/
1030static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1031 struct ipr_hostrcb *hostrcb)
1032{
1033 struct ipr_hostrcb_type_02_error *error =
1034 &hostrcb->hcam.u.error.u.type_02_error;
1035
1036 ipr_err("-----Current Configuration-----\n");
1037 ipr_err("Cache Directory Card Information:\n");
cfc32139 1038 ipr_log_vpd(&error->ioa_vpd);
1da177e4 1039 ipr_err("Adapter Card Information:\n");
cfc32139 1040 ipr_log_vpd(&error->cfc_vpd);
1da177e4
LT		 1041
1042 ipr_err("-----Expected Configuration-----\n");
1043 ipr_err("Cache Directory Card Information:\n");
cfc32139 1044 ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1da177e4 1045 ipr_err("Adapter Card Information:\n");
cfc32139 1046 ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1da177e4
LT		 1047
1048 ipr_err("Additional IOA Data: %08X %08X %08X\n",
1049 be32_to_cpu(error->ioa_data[0]),
1050 be32_to_cpu(error->ioa_data[1]),
1051 be32_to_cpu(error->ioa_data[2]));
1052}
1053
ee0f05b8
BK		 1054/**
1055 * ipr_log_enhanced_config_error - Log a configuration error.
1056 * @ioa_cfg: ioa config struct
1057 * @hostrcb: hostrcb struct
1058 *
1059 * Return value:
1060 * none
1061 **/
1062static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1063 struct ipr_hostrcb *hostrcb)
1064{
1065 int errors_logged, i;
1066 struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1067 struct ipr_hostrcb_type_13_error *error;
1068
1069 error = &hostrcb->hcam.u.error.u.type_13_error;
1070 errors_logged = be32_to_cpu(error->errors_logged);
1071
1072 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1073 be32_to_cpu(error->errors_detected), errors_logged);
1074
1075 dev_entry = error->dev;
1076
1077 for (i = 0; i < errors_logged; i++, dev_entry++) {
1078 ipr_err_separator;
1079
1080 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1081 ipr_log_ext_vpd(&dev_entry->vpd);
1082
1083 ipr_err("-----New Device Information-----\n");
1084 ipr_log_ext_vpd(&dev_entry->new_vpd);
1085
1086 ipr_err("Cache Directory Card Information:\n");
1087 ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1088
1089 ipr_err("Adapter Card Information:\n");
1090 ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1091 }
1092}
1093
1da177e4
LT		 1094/**
1095 * ipr_log_config_error - Log a configuration error.
1096 * @ioa_cfg: ioa config struct
1097 * @hostrcb: hostrcb struct
1098 *
1099 * Return value:
1100 * none
1101 **/
1102static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1103 struct ipr_hostrcb *hostrcb)
1104{
1105 int errors_logged, i;
1106 struct ipr_hostrcb_device_data_entry *dev_entry;
1107 struct ipr_hostrcb_type_03_error *error;
1108
1109 error = &hostrcb->hcam.u.error.u.type_03_error;
1110 errors_logged = be32_to_cpu(error->errors_logged);
1111
1112 ipr_err("Device Errors Detected/Logged: %d/%d\n",
1113 be32_to_cpu(error->errors_detected), errors_logged);
1114
cfc32139 1115 dev_entry = error->dev;
1da177e4
LT		 1116
1117 for (i = 0; i < errors_logged; i++, dev_entry++) {
1118 ipr_err_separator;
1119
fa15b1f6 1120 ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
cfc32139 1121 ipr_log_vpd(&dev_entry->vpd);
1da177e4
LT		 1122
1123 ipr_err("-----New Device Information-----\n");
cfc32139 1124 ipr_log_vpd(&dev_entry->new_vpd);
1da177e4
LT		 1125
1126 ipr_err("Cache Directory Card Information:\n");
cfc32139 1127 ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1da177e4
LT		 1128
1129 ipr_err("Adapter Card Information:\n");
cfc32139 1130 ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1da177e4
LT		 1131
1132 ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1133 be32_to_cpu(dev_entry->ioa_data[0]),
1134 be32_to_cpu(dev_entry->ioa_data[1]),
1135 be32_to_cpu(dev_entry->ioa_data[2]),
1136 be32_to_cpu(dev_entry->ioa_data[3]),
1137 be32_to_cpu(dev_entry->ioa_data[4]));
1138 }
1139}
1140
ee0f05b8
BK		 1141/**
1142 * ipr_log_enhanced_array_error - Log an array configuration error.
1143 * @ioa_cfg: ioa config struct
1144 * @hostrcb: hostrcb struct
1145 *
1146 * Return value:
1147 * none
1148 **/
1149static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1150 struct ipr_hostrcb *hostrcb)
1151{
1152 int i, num_entries;
1153 struct ipr_hostrcb_type_14_error *error;
1154 struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1155 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1156
1157 error = &hostrcb->hcam.u.error.u.type_14_error;
1158
1159 ipr_err_separator;
1160
1161 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1162 error->protection_level,
1163 ioa_cfg->host->host_no,
1164 error->last_func_vset_res_addr.bus,
1165 error->last_func_vset_res_addr.target,
1166 error->last_func_vset_res_addr.lun);
1167
1168 ipr_err_separator;
1169
1170 array_entry = error->array_member;
1171 num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1172 sizeof(error->array_member));
1173
1174 for (i = 0; i < num_entries; i++, array_entry++) {
1175 if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1176 continue;
1177
1178 if (be32_to_cpu(error->exposed_mode_adn) == i)
1179 ipr_err("Exposed Array Member %d:\n", i);
1180 else
1181 ipr_err("Array Member %d:\n", i);
1182
1183 ipr_log_ext_vpd(&array_entry->vpd);
1184 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1185 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1186 "Expected Location");
1187
1188 ipr_err_separator;
1189 }
1190}
1191
1da177e4
LT		 1192/**
1193 * ipr_log_array_error - Log an array configuration error.
1194 * @ioa_cfg: ioa config struct
1195 * @hostrcb: hostrcb struct
1196 *
1197 * Return value:
1198 * none
1199 **/
1200static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1201 struct ipr_hostrcb *hostrcb)
1202{
1203 int i;
1204 struct ipr_hostrcb_type_04_error *error;
1205 struct ipr_hostrcb_array_data_entry *array_entry;
1206 const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1207
1208 error = &hostrcb->hcam.u.error.u.type_04_error;
1209
1210 ipr_err_separator;
1211
1212 ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1213 error->protection_level,
1214 ioa_cfg->host->host_no,
1215 error->last_func_vset_res_addr.bus,
1216 error->last_func_vset_res_addr.target,
1217 error->last_func_vset_res_addr.lun);
1218
1219 ipr_err_separator;
1220
1221 array_entry = error->array_member;
1222
1223 for (i = 0; i < 18; i++) {
cfc32139 1224 if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1da177e4
LT		 1225 continue;
1226
fa15b1f6 1227 if (be32_to_cpu(error->exposed_mode_adn) == i)
1da177e4 1228 ipr_err("Exposed Array Member %d:\n", i);
fa15b1f6 1229 else
1da177e4 1230 ipr_err("Array Member %d:\n", i);
1da177e4 1231
cfc32139 1232 ipr_log_vpd(&array_entry->vpd);
1da177e4 1233
fa15b1f6
BK		 1234 ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1235 ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1236 "Expected Location");
1da177e4
LT		 1237
1238 ipr_err_separator;
1239
1240 if (i == 9)
1241 array_entry = error->array_member2;
1242 else
1243 array_entry++;
1244 }
1245}
1246
1247/**
b0df54bb 1248 * ipr_log_hex_data - Log additional hex IOA error data.
ac719aba 1249 * @ioa_cfg: ioa config struct
b0df54bb
BK		 1250 * @data: IOA error data
1251 * @len: data length
1da177e4
LT		 1252 *
1253 * Return value:
1254 * none
1255 **/
ac719aba 1256static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, u32 *data, int len)
1da177e4
LT		 1257{
1258 int i;
1da177e4 1259
b0df54bb 1260 if (len == 0)
1da177e4
LT		 1261 return;
1262
ac719aba
BK		 1263 if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1264 len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1265
b0df54bb 1266 for (i = 0; i < len / 4; i += 4) {
1da177e4 1267 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
b0df54bb
BK		 1268 be32_to_cpu(data[i]),
1269 be32_to_cpu(data[i+1]),
1270 be32_to_cpu(data[i+2]),
1271 be32_to_cpu(data[i+3]));
1da177e4
LT		 1272 }
1273}
1274
ee0f05b8
BK		 1275/**
1276 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1277 * @ioa_cfg: ioa config struct
1278 * @hostrcb: hostrcb struct
1279 *
1280 * Return value:
1281 * none
1282 **/
1283static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1284 struct ipr_hostrcb *hostrcb)
1285{
1286 struct ipr_hostrcb_type_17_error *error;
1287
1288 error = &hostrcb->hcam.u.error.u.type_17_error;
1289 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1290
1291 ipr_err("%s\n", error->failure_reason);
1292 ipr_err("Remote Adapter VPD:\n");
1293 ipr_log_ext_vpd(&error->vpd);
ac719aba 1294 ipr_log_hex_data(ioa_cfg, error->data,
ee0f05b8
BK		 1295 be32_to_cpu(hostrcb->hcam.length) -
1296 (offsetof(struct ipr_hostrcb_error, u) +
1297 offsetof(struct ipr_hostrcb_type_17_error, data)));
1298}
1299
b0df54bb
BK		 1300/**
1301 * ipr_log_dual_ioa_error - Log a dual adapter error.
1302 * @ioa_cfg: ioa config struct
1303 * @hostrcb: hostrcb struct
1304 *
1305 * Return value:
1306 * none
1307 **/
1308static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1309 struct ipr_hostrcb *hostrcb)
1310{
1311 struct ipr_hostrcb_type_07_error *error;
1312
1313 error = &hostrcb->hcam.u.error.u.type_07_error;
1314 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1315
1316 ipr_err("%s\n", error->failure_reason);
1317 ipr_err("Remote Adapter VPD:\n");
1318 ipr_log_vpd(&error->vpd);
ac719aba 1319 ipr_log_hex_data(ioa_cfg, error->data,
b0df54bb
BK		 1320 be32_to_cpu(hostrcb->hcam.length) -
1321 (offsetof(struct ipr_hostrcb_error, u) +
1322 offsetof(struct ipr_hostrcb_type_07_error, data)));
1323}
1324
49dc6a18
BK		 1325static const struct {
1326 u8 active;
1327 char *desc;
1328} path_active_desc[] = {
1329 { IPR_PATH_NO_INFO, "Path" },
1330 { IPR_PATH_ACTIVE, "Active path" },
1331 { IPR_PATH_NOT_ACTIVE, "Inactive path" }
1332};
1333
1334static const struct {
1335 u8 state;
1336 char *desc;
1337} path_state_desc[] = {
1338 { IPR_PATH_STATE_NO_INFO, "has no path state information available" },
1339 { IPR_PATH_HEALTHY, "is healthy" },
1340 { IPR_PATH_DEGRADED, "is degraded" },
1341 { IPR_PATH_FAILED, "is failed" }
1342};
1343
1344/**
1345 * ipr_log_fabric_path - Log a fabric path error
1346 * @hostrcb: hostrcb struct
1347 * @fabric: fabric descriptor
1348 *
1349 * Return value:
1350 * none
1351 **/
1352static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
1353 struct ipr_hostrcb_fabric_desc *fabric)
1354{
1355 int i, j;
1356 u8 path_state = fabric->path_state;
1357 u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1358 u8 state = path_state & IPR_PATH_STATE_MASK;
1359
1360 for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1361 if (path_active_desc[i].active != active)
1362 continue;
1363
1364 for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1365 if (path_state_desc[j].state != state)
1366 continue;
1367
1368 if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
1369 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
1370 path_active_desc[i].desc, path_state_desc[j].desc,
1371 fabric->ioa_port);
1372 } else if (fabric->cascaded_expander == 0xff) {
1373 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
1374 path_active_desc[i].desc, path_state_desc[j].desc,
1375 fabric->ioa_port, fabric->phy);
1376 } else if (fabric->phy == 0xff) {
1377 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
1378 path_active_desc[i].desc, path_state_desc[j].desc,
1379 fabric->ioa_port, fabric->cascaded_expander);
1380 } else {
1381 ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
1382 path_active_desc[i].desc, path_state_desc[j].desc,
1383 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1384 }
1385 return;
1386 }
1387 }
1388
1389 ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
1390 fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1391}
1392
1393static const struct {
1394 u8 type;
1395 char *desc;
1396} path_type_desc[] = {
1397 { IPR_PATH_CFG_IOA_PORT, "IOA port" },
1398 { IPR_PATH_CFG_EXP_PORT, "Expander port" },
1399 { IPR_PATH_CFG_DEVICE_PORT, "Device port" },
1400 { IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
1401};
1402
1403static const struct {
1404 u8 status;
1405 char *desc;
1406} path_status_desc[] = {
1407 { IPR_PATH_CFG_NO_PROB, "Functional" },
1408 { IPR_PATH_CFG_DEGRADED, "Degraded" },
1409 { IPR_PATH_CFG_FAILED, "Failed" },
1410 { IPR_PATH_CFG_SUSPECT, "Suspect" },
1411 { IPR_PATH_NOT_DETECTED, "Missing" },
1412 { IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
1413};
1414
1415static const char *link_rate[] = {
1416 "unknown",
1417 "disabled",
1418 "phy reset problem",
1419 "spinup hold",
1420 "port selector",
1421 "unknown",
1422 "unknown",
1423 "unknown",
1424 "1.5Gbps",
1425 "3.0Gbps",
1426 "unknown",
1427 "unknown",
1428 "unknown",
1429 "unknown",
1430 "unknown",
1431 "unknown"
1432};
1433
1434/**
1435 * ipr_log_path_elem - Log a fabric path element.
1436 * @hostrcb: hostrcb struct
1437 * @cfg: fabric path element struct
1438 *
1439 * Return value:
1440 * none
1441 **/
1442static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
1443 struct ipr_hostrcb_config_element *cfg)
1444{
1445 int i, j;
1446 u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
1447 u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
1448
1449 if (type == IPR_PATH_CFG_NOT_EXIST)
1450 return;
1451
1452 for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
1453 if (path_type_desc[i].type != type)
1454 continue;
1455
1456 for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
1457 if (path_status_desc[j].status != status)
1458 continue;
1459
1460 if (type == IPR_PATH_CFG_IOA_PORT) {
1461 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
1462 path_status_desc[j].desc, path_type_desc[i].desc,
1463 cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1464 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1465 } else {
1466 if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
1467 ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
1468 path_status_desc[j].desc, path_type_desc[i].desc,
1469 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1470 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1471 } else if (cfg->cascaded_expander == 0xff) {
1472 ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
1473 "WWN=%08X%08X\n", path_status_desc[j].desc,
1474 path_type_desc[i].desc, cfg->phy,
1475 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1476 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1477 } else if (cfg->phy == 0xff) {
1478 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
1479 "WWN=%08X%08X\n", path_status_desc[j].desc,
1480 path_type_desc[i].desc, cfg->cascaded_expander,
1481 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1482 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1483 } else {
1484 ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
1485 "WWN=%08X%08X\n", path_status_desc[j].desc,
1486 path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
1487 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1488 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1489 }
1490 }
1491 return;
1492 }
1493 }
1494
1495 ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
1496 "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
1497 link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
1498 be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
1499}
1500
1501/**
1502 * ipr_log_fabric_error - Log a fabric error.
1503 * @ioa_cfg: ioa config struct
1504 * @hostrcb: hostrcb struct
1505 *
1506 * Return value:
1507 * none
1508 **/
1509static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
1510 struct ipr_hostrcb *hostrcb)
1511{
1512 struct ipr_hostrcb_type_20_error *error;
1513 struct ipr_hostrcb_fabric_desc *fabric;
1514 struct ipr_hostrcb_config_element *cfg;
1515 int i, add_len;
1516
1517 error = &hostrcb->hcam.u.error.u.type_20_error;
1518 error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1519 ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
1520
1521 add_len = be32_to_cpu(hostrcb->hcam.length) -
1522 (offsetof(struct ipr_hostrcb_error, u) +
1523 offsetof(struct ipr_hostrcb_type_20_error, desc));
1524
1525 for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
1526 ipr_log_fabric_path(hostrcb, fabric);
1527 for_each_fabric_cfg(fabric, cfg)
1528 ipr_log_path_elem(hostrcb, cfg);
1529
1530 add_len -= be16_to_cpu(fabric->length);
1531 fabric = (struct ipr_hostrcb_fabric_desc *)
1532 ((unsigned long)fabric + be16_to_cpu(fabric->length));
1533 }
1534
ac719aba 1535 ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
49dc6a18
BK		 1536}
1537
b0df54bb
BK		 1538/**
1539 * ipr_log_generic_error - Log an adapter error.
1540 * @ioa_cfg: ioa config struct
1541 * @hostrcb: hostrcb struct
1542 *
1543 * Return value:
1544 * none
1545 **/
1546static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
1547 struct ipr_hostrcb *hostrcb)
1548{
ac719aba 1549 ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
b0df54bb
BK		 1550 be32_to_cpu(hostrcb->hcam.length));
1551}
1552
1da177e4
LT		 1553/**
1554 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
1555 * @ioasc: IOASC
1556 *
1557 * This function will return the index of into the ipr_error_table
1558 * for the specified IOASC. If the IOASC is not in the table,
1559 * 0 will be returned, which points to the entry used for unknown errors.
1560 *
1561 * Return value:
1562 * index into the ipr_error_table
1563 **/
1564static u32 ipr_get_error(u32 ioasc)
1565{
1566 int i;
1567
1568 for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
35a39691 1569 if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
1da177e4
LT		 1570 return i;
1571
1572 return 0;
1573}
1574
1575/**
1576 * ipr_handle_log_data - Log an adapter error.
1577 * @ioa_cfg: ioa config struct
1578 * @hostrcb: hostrcb struct
1579 *
1580 * This function logs an adapter error to the system.
1581 *
1582 * Return value:
1583 * none
1584 **/
1585static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
1586 struct ipr_hostrcb *hostrcb)
1587{
1588 u32 ioasc;
1589 int error_index;
1590
1591 if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
1592 return;
1593
1594 if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
1595 dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
1596
1597 ioasc = be32_to_cpu(hostrcb->hcam.u.error.failing_dev_ioasc);
1598
1599 if (ioasc == IPR_IOASC_BUS_WAS_RESET ||
1600 ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER) {
1601 /* Tell the midlayer we had a bus reset so it will handle the UA properly */
1602 scsi_report_bus_reset(ioa_cfg->host,
1603 hostrcb->hcam.u.error.failing_dev_res_addr.bus);
1604 }
1605
1606 error_index = ipr_get_error(ioasc);
1607
1608 if (!ipr_error_table[error_index].log_hcam)
1609 return;
1610
49dc6a18 1611 ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
1da177e4
LT		 1612
1613 /* Set indication we have logged an error */
1614 ioa_cfg->errors_logged++;
1615
933916f3 1616 if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
1da177e4 1617 return;
cf852037
BK		 1618 if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
1619 hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
1da177e4
LT		 1620
1621 switch (hostrcb->hcam.overlay_id) {
1da177e4
LT		 1622 case IPR_HOST_RCB_OVERLAY_ID_2:
1623 ipr_log_cache_error(ioa_cfg, hostrcb);
1624 break;
1625 case IPR_HOST_RCB_OVERLAY_ID_3:
1626 ipr_log_config_error(ioa_cfg, hostrcb);
1627 break;
1628 case IPR_HOST_RCB_OVERLAY_ID_4:
1629 case IPR_HOST_RCB_OVERLAY_ID_6:
1630 ipr_log_array_error(ioa_cfg, hostrcb);
1631 break;
b0df54bb
BK		 1632 case IPR_HOST_RCB_OVERLAY_ID_7:
1633 ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
1634 break;
ee0f05b8
BK		 1635 case IPR_HOST_RCB_OVERLAY_ID_12:
1636 ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
1637 break;
1638 case IPR_HOST_RCB_OVERLAY_ID_13:
1639 ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
1640 break;
1641 case IPR_HOST_RCB_OVERLAY_ID_14:
1642 case IPR_HOST_RCB_OVERLAY_ID_16:
1643 ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
1644 break;
1645 case IPR_HOST_RCB_OVERLAY_ID_17:
1646 ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
1647 break;
49dc6a18
BK		 1648 case IPR_HOST_RCB_OVERLAY_ID_20:
1649 ipr_log_fabric_error(ioa_cfg, hostrcb);
1650 break;
cf852037 1651 case IPR_HOST_RCB_OVERLAY_ID_1:
1da177e4 1652 case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
1da177e4 1653 default:
a9cfca96 1654 ipr_log_generic_error(ioa_cfg, hostrcb);
1da177e4
LT		 1655 break;
1656 }
1657}
1658
1659/**
1660 * ipr_process_error - Op done function for an adapter error log.
1661 * @ipr_cmd: ipr command struct
1662 *
1663 * This function is the op done function for an error log host
1664 * controlled async from the adapter. It will log the error and
1665 * send the HCAM back to the adapter.
1666 *
1667 * Return value:
1668 * none
1669 **/
1670static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
1671{
1672 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1673 struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1674 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
1675
1676 list_del(&hostrcb->queue);
1677 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
1678
1679 if (!ioasc) {
1680 ipr_handle_log_data(ioa_cfg, hostrcb);
1681 } else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
1682 dev_err(&ioa_cfg->pdev->dev,
1683 "Host RCB failed with IOASC: 0x%08X\n", ioasc);
1684 }
1685
1686 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
1687}
1688
1689/**
1690 * ipr_timeout - An internally generated op has timed out.
1691 * @ipr_cmd: ipr command struct
1692 *
1693 * This function blocks host requests and initiates an
1694 * adapter reset.
1695 *
1696 * Return value:
1697 * none
1698 **/
1699static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
1700{
1701 unsigned long lock_flags = 0;
1702 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1703
1704 ENTER;
1705 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1706
1707 ioa_cfg->errors_logged++;
1708 dev_err(&ioa_cfg->pdev->dev,
1709 "Adapter being reset due to command timeout.\n");
1710
1711 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1712 ioa_cfg->sdt_state = GET_DUMP;
1713
1714 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
1715 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1716
1717 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1718 LEAVE;
1719}
1720
1721/**
1722 * ipr_oper_timeout - Adapter timed out transitioning to operational
1723 * @ipr_cmd: ipr command struct
1724 *
1725 * This function blocks host requests and initiates an
1726 * adapter reset.
1727 *
1728 * Return value:
1729 * none
1730 **/
1731static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
1732{
1733 unsigned long lock_flags = 0;
1734 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1735
1736 ENTER;
1737 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
1738
1739 ioa_cfg->errors_logged++;
1740 dev_err(&ioa_cfg->pdev->dev,
1741 "Adapter timed out transitioning to operational.\n");
1742
1743 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
1744 ioa_cfg->sdt_state = GET_DUMP;
1745
1746 if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
1747 if (ipr_fastfail)
1748 ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
1749 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
1750 }
1751
1752 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1753 LEAVE;
1754}
1755
1756/**
1757 * ipr_reset_reload - Reset/Reload the IOA
1758 * @ioa_cfg: ioa config struct
1759 * @shutdown_type: shutdown type
1760 *
1761 * This function resets the adapter and re-initializes it.
1762 * This function assumes that all new host commands have been stopped.
1763 * Return value:
1764 * SUCCESS / FAILED
1765 **/
1766static int ipr_reset_reload(struct ipr_ioa_cfg *ioa_cfg,
1767 enum ipr_shutdown_type shutdown_type)
1768{
1769 if (!ioa_cfg->in_reset_reload)
1770 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
1771
1772 spin_unlock_irq(ioa_cfg->host->host_lock);
1773 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
1774 spin_lock_irq(ioa_cfg->host->host_lock);
1775
1776 /* If we got hit with a host reset while we were already resetting
1777 the adapter for some reason, and the reset failed. */
1778 if (ioa_cfg->ioa_is_dead) {
1779 ipr_trace;
1780 return FAILED;
1781 }
1782
1783 return SUCCESS;
1784}
1785
1786/**
1787 * ipr_find_ses_entry - Find matching SES in SES table
1788 * @res: resource entry struct of SES
1789 *
1790 * Return value:
1791 * pointer to SES table entry / NULL on failure
1792 **/
1793static const struct ipr_ses_table_entry *
1794ipr_find_ses_entry(struct ipr_resource_entry *res)
1795{
1796 int i, j, matches;
1797 const struct ipr_ses_table_entry *ste = ipr_ses_table;
1798
1799 for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
1800 for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
1801 if (ste->compare_product_id_byte[j] == 'X') {
1802 if (res->cfgte.std_inq_data.vpids.product_id[j] == ste->product_id[j])
1803 matches++;
1804 else
1805 break;
1806 } else
1807 matches++;
1808 }
1809
1810 if (matches == IPR_PROD_ID_LEN)
1811 return ste;
1812 }
1813
1814 return NULL;
1815}
1816
1817/**
1818 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
1819 * @ioa_cfg: ioa config struct
1820 * @bus: SCSI bus
1821 * @bus_width: bus width
1822 *
1823 * Return value:
1824 * SCSI bus speed in units of 100KHz, 1600 is 160 MHz
1825 * For a 2-byte wide SCSI bus, the maximum transfer speed is
1826 * twice the maximum transfer rate (e.g. for a wide enabled bus,
1827 * max 160MHz = max 320MB/sec).
1828 **/
1829static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
1830{
1831 struct ipr_resource_entry *res;
1832 const struct ipr_ses_table_entry *ste;
1833 u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
1834
1835 /* Loop through each config table entry in the config table buffer */
1836 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1837 if (!(IPR_IS_SES_DEVICE(res->cfgte.std_inq_data)))
1838 continue;
1839
1840 if (bus != res->cfgte.res_addr.bus)
1841 continue;
1842
1843 if (!(ste = ipr_find_ses_entry(res)))
1844 continue;
1845
1846 max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
1847 }
1848
1849 return max_xfer_rate;
1850}
1851
1852/**
1853 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
1854 * @ioa_cfg: ioa config struct
1855 * @max_delay: max delay in micro-seconds to wait
1856 *
1857 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
1858 *
1859 * Return value:
1860 * 0 on success / other on failure
1861 **/
1862static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
1863{
1864 volatile u32 pcii_reg;
1865 int delay = 1;
1866
1867 /* Read interrupt reg until IOA signals IO Debug Acknowledge */
1868 while (delay < max_delay) {
1869 pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
1870
1871 if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
1872 return 0;
1873
1874 /* udelay cannot be used if delay is more than a few milliseconds */
1875 if ((delay / 1000) > MAX_UDELAY_MS)
1876 mdelay(delay / 1000);
1877 else
1878 udelay(delay);
1879
1880 delay += delay;
1881 }
1882 return -EIO;
1883}
1884
1885/**
1886 * ipr_get_ldump_data_section - Dump IOA memory
1887 * @ioa_cfg: ioa config struct
1888 * @start_addr: adapter address to dump
1889 * @dest: destination kernel buffer
1890 * @length_in_words: length to dump in 4 byte words
1891 *
1892 * Return value:
1893 * 0 on success / -EIO on failure
1894 **/
1895static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
1896 u32 start_addr,
1897 __be32 *dest, u32 length_in_words)
1898{
1899 volatile u32 temp_pcii_reg;
1900 int i, delay = 0;
1901
1902 /* Write IOA interrupt reg starting LDUMP state */
1903 writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
1904 ioa_cfg->regs.set_uproc_interrupt_reg);
1905
1906 /* Wait for IO debug acknowledge */
1907 if (ipr_wait_iodbg_ack(ioa_cfg,
1908 IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
1909 dev_err(&ioa_cfg->pdev->dev,
1910 "IOA dump long data transfer timeout\n");
1911 return -EIO;
1912 }
1913
1914 /* Signal LDUMP interlocked - clear IO debug ack */
1915 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1916 ioa_cfg->regs.clr_interrupt_reg);
1917
1918 /* Write Mailbox with starting address */
1919 writel(start_addr, ioa_cfg->ioa_mailbox);
1920
1921 /* Signal address valid - clear IOA Reset alert */
1922 writel(IPR_UPROCI_RESET_ALERT,
1923 ioa_cfg->regs.clr_uproc_interrupt_reg);
1924
1925 for (i = 0; i < length_in_words; i++) {
1926 /* Wait for IO debug acknowledge */
1927 if (ipr_wait_iodbg_ack(ioa_cfg,
1928 IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
1929 dev_err(&ioa_cfg->pdev->dev,
1930 "IOA dump short data transfer timeout\n");
1931 return -EIO;
1932 }
1933
1934 /* Read data from mailbox and increment destination pointer */
1935 *dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
1936 dest++;
1937
1938 /* For all but the last word of data, signal data received */
1939 if (i < (length_in_words - 1)) {
1940 /* Signal dump data received - Clear IO debug Ack */
1941 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1942 ioa_cfg->regs.clr_interrupt_reg);
1943 }
1944 }
1945
1946 /* Signal end of block transfer. Set reset alert then clear IO debug ack */
1947 writel(IPR_UPROCI_RESET_ALERT,
1948 ioa_cfg->regs.set_uproc_interrupt_reg);
1949
1950 writel(IPR_UPROCI_IO_DEBUG_ALERT,
1951 ioa_cfg->regs.clr_uproc_interrupt_reg);
1952
1953 /* Signal dump data received - Clear IO debug Ack */
1954 writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
1955 ioa_cfg->regs.clr_interrupt_reg);
1956
1957 /* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
1958 while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
1959 temp_pcii_reg =
1960 readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
1961
1962 if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
1963 return 0;
1964
1965 udelay(10);
1966 delay += 10;
1967 }
1968
1969 return 0;
1970}
1971
1972#ifdef CONFIG_SCSI_IPR_DUMP
1973/**
1974 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
1975 * @ioa_cfg: ioa config struct
1976 * @pci_address: adapter address
1977 * @length: length of data to copy
1978 *
1979 * Copy data from PCI adapter to kernel buffer.
1980 * Note: length MUST be a 4 byte multiple
1981 * Return value:
1982 * 0 on success / other on failure
1983 **/
1984static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
1985 unsigned long pci_address, u32 length)
1986{
1987 int bytes_copied = 0;
1988 int cur_len, rc, rem_len, rem_page_len;
1989 __be32 *page;
1990 unsigned long lock_flags = 0;
1991 struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
1992
1993 while (bytes_copied < length &&
1994 (ioa_dump->hdr.len + bytes_copied) < IPR_MAX_IOA_DUMP_SIZE) {
1995 if (ioa_dump->page_offset >= PAGE_SIZE ||
1996 ioa_dump->page_offset == 0) {
1997 page = (__be32 *)__get_free_page(GFP_ATOMIC);
1998
1999 if (!page) {
2000 ipr_trace;
2001 return bytes_copied;
2002 }
2003
2004 ioa_dump->page_offset = 0;
2005 ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2006 ioa_dump->next_page_index++;
2007 } else
2008 page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2009
2010 rem_len = length - bytes_copied;
2011 rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2012 cur_len = min(rem_len, rem_page_len);
2013
2014 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2015 if (ioa_cfg->sdt_state == ABORT_DUMP) {
2016 rc = -EIO;
2017 } else {
2018 rc = ipr_get_ldump_data_section(ioa_cfg,
2019 pci_address + bytes_copied,
2020 &page[ioa_dump->page_offset / 4],
2021 (cur_len / sizeof(u32)));
2022 }
2023 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2024
2025 if (!rc) {
2026 ioa_dump->page_offset += cur_len;
2027 bytes_copied += cur_len;
2028 } else {
2029 ipr_trace;
2030 break;
2031 }
2032 schedule();
2033 }
2034
2035 return bytes_copied;
2036}
2037
2038/**
2039 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
2040 * @hdr: dump entry header struct
2041 *
2042 * Return value:
2043 * nothing
2044 **/
2045static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
2046{
2047 hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
2048 hdr->num_elems = 1;
2049 hdr->offset = sizeof(*hdr);
2050 hdr->status = IPR_DUMP_STATUS_SUCCESS;
2051}
2052
2053/**
2054 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
2055 * @ioa_cfg: ioa config struct
2056 * @driver_dump: driver dump struct
2057 *
2058 * Return value:
2059 * nothing
2060 **/
2061static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
2062 struct ipr_driver_dump *driver_dump)
2063{
2064 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2065
2066 ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
2067 driver_dump->ioa_type_entry.hdr.len =
2068 sizeof(struct ipr_dump_ioa_type_entry) -
2069 sizeof(struct ipr_dump_entry_header);
2070 driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2071 driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
2072 driver_dump->ioa_type_entry.type = ioa_cfg->type;
2073 driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
2074 (ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
2075 ucode_vpd->minor_release[1];
2076 driver_dump->hdr.num_entries++;
2077}
2078
2079/**
2080 * ipr_dump_version_data - Fill in the driver version in the dump.
2081 * @ioa_cfg: ioa config struct
2082 * @driver_dump: driver dump struct
2083 *
2084 * Return value:
2085 * nothing
2086 **/
2087static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
2088 struct ipr_driver_dump *driver_dump)
2089{
2090 ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
2091 driver_dump->version_entry.hdr.len =
2092 sizeof(struct ipr_dump_version_entry) -
2093 sizeof(struct ipr_dump_entry_header);
2094 driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2095 driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
2096 strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
2097 driver_dump->hdr.num_entries++;
2098}
2099
2100/**
2101 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
2102 * @ioa_cfg: ioa config struct
2103 * @driver_dump: driver dump struct
2104 *
2105 * Return value:
2106 * nothing
2107 **/
2108static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
2109 struct ipr_driver_dump *driver_dump)
2110{
2111 ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
2112 driver_dump->trace_entry.hdr.len =
2113 sizeof(struct ipr_dump_trace_entry) -
2114 sizeof(struct ipr_dump_entry_header);
2115 driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2116 driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
2117 memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
2118 driver_dump->hdr.num_entries++;
2119}
2120
2121/**
2122 * ipr_dump_location_data - Fill in the IOA location in the dump.
2123 * @ioa_cfg: ioa config struct
2124 * @driver_dump: driver dump struct
2125 *
2126 * Return value:
2127 * nothing
2128 **/
2129static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
2130 struct ipr_driver_dump *driver_dump)
2131{
2132 ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
2133 driver_dump->location_entry.hdr.len =
2134 sizeof(struct ipr_dump_location_entry) -
2135 sizeof(struct ipr_dump_entry_header);
2136 driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2137 driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
2138 strcpy(driver_dump->location_entry.location, ioa_cfg->pdev->dev.bus_id);
2139 driver_dump->hdr.num_entries++;
2140}
2141
2142/**
2143 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
2144 * @ioa_cfg: ioa config struct
2145 * @dump: dump struct
2146 *
2147 * Return value:
2148 * nothing
2149 **/
2150static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
2151{
2152 unsigned long start_addr, sdt_word;
2153 unsigned long lock_flags = 0;
2154 struct ipr_driver_dump *driver_dump = &dump->driver_dump;
2155 struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
2156 u32 num_entries, start_off, end_off;
2157 u32 bytes_to_copy, bytes_copied, rc;
2158 struct ipr_sdt *sdt;
2159 int i;
2160
2161 ENTER;
2162
2163 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2164
2165 if (ioa_cfg->sdt_state != GET_DUMP) {
2166 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2167 return;
2168 }
2169
2170 start_addr = readl(ioa_cfg->ioa_mailbox);
2171
2172 if (!ipr_sdt_is_fmt2(start_addr)) {
2173 dev_err(&ioa_cfg->pdev->dev,
2174 "Invalid dump table format: %lx\n", start_addr);
2175 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2176 return;
2177 }
2178
2179 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
2180
2181 driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
2182
2183 /* Initialize the overall dump header */
2184 driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
2185 driver_dump->hdr.num_entries = 1;
2186 driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
2187 driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
2188 driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
2189 driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
2190
2191 ipr_dump_version_data(ioa_cfg, driver_dump);
2192 ipr_dump_location_data(ioa_cfg, driver_dump);
2193 ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
2194 ipr_dump_trace_data(ioa_cfg, driver_dump);
2195
2196 /* Update dump_header */
2197 driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
2198
2199 /* IOA Dump entry */
2200 ipr_init_dump_entry_hdr(&ioa_dump->hdr);
2201 ioa_dump->format = IPR_SDT_FMT2;
2202 ioa_dump->hdr.len = 0;
2203 ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2204 ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
2205
2206 /* First entries in sdt are actually a list of dump addresses and
2207 lengths to gather the real dump data. sdt represents the pointer
2208 to the ioa generated dump table. Dump data will be extracted based
2209 on entries in this table */
2210 sdt = &ioa_dump->sdt;
2211
2212 rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
2213 sizeof(struct ipr_sdt) / sizeof(__be32));
2214
2215 /* Smart Dump table is ready to use and the first entry is valid */
2216 if (rc || (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE)) {
2217 dev_err(&ioa_cfg->pdev->dev,
2218 "Dump of IOA failed. Dump table not valid: %d, %X.\n",
2219 rc, be32_to_cpu(sdt->hdr.state));
2220 driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
2221 ioa_cfg->sdt_state = DUMP_OBTAINED;
2222 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2223 return;
2224 }
2225
2226 num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
2227
2228 if (num_entries > IPR_NUM_SDT_ENTRIES)
2229 num_entries = IPR_NUM_SDT_ENTRIES;
2230
2231 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2232
2233 for (i = 0; i < num_entries; i++) {
2234 if (ioa_dump->hdr.len > IPR_MAX_IOA_DUMP_SIZE) {
2235 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
2236 break;
2237 }
2238
2239 if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
2240 sdt_word = be32_to_cpu(sdt->entry[i].bar_str_offset);
2241 start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
2242 end_off = be32_to_cpu(sdt->entry[i].end_offset);
2243
2244 if (ipr_sdt_is_fmt2(sdt_word) && sdt_word) {
2245 bytes_to_copy = end_off - start_off;
2246 if (bytes_to_copy > IPR_MAX_IOA_DUMP_SIZE) {
2247 sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
2248 continue;
2249 }
2250
2251 /* Copy data from adapter to driver buffers */
2252 bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
2253 bytes_to_copy);
2254
2255 ioa_dump->hdr.len += bytes_copied;
2256
2257 if (bytes_copied != bytes_to_copy) {
2258 driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
2259 break;
2260 }
2261 }
2262 }
2263 }
2264
2265 dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
2266
2267 /* Update dump_header */
2268 driver_dump->hdr.len += ioa_dump->hdr.len;
2269 wmb();
2270 ioa_cfg->sdt_state = DUMP_OBTAINED;
2271 LEAVE;
2272}
2273
2274#else
2275#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while(0)
2276#endif
2277
2278/**
2279 * ipr_release_dump - Free adapter dump memory
2280 * @kref: kref struct
2281 *
2282 * Return value:
2283 * nothing
2284 **/
2285static void ipr_release_dump(struct kref *kref)
2286{
2287 struct ipr_dump *dump = container_of(kref,struct ipr_dump,kref);
2288 struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
2289 unsigned long lock_flags = 0;
2290 int i;
2291
2292 ENTER;
2293 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2294 ioa_cfg->dump = NULL;
2295 ioa_cfg->sdt_state = INACTIVE;
2296 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2297
2298 for (i = 0; i < dump->ioa_dump.next_page_index; i++)
2299 free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
2300
2301 kfree(dump);
2302 LEAVE;
2303}
2304
2305/**
2306 * ipr_worker_thread - Worker thread
c4028958 2307 * @work: ioa config struct
1da177e4
LT		 2308 *
2309 * Called at task level from a work thread. This function takes care
2310 * of adding and removing device from the mid-layer as configuration
2311 * changes are detected by the adapter.
2312 *
2313 * Return value:
2314 * nothing
2315 **/
c4028958 2316static void ipr_worker_thread(struct work_struct *work)
1da177e4
LT		 2317{
2318 unsigned long lock_flags;
2319 struct ipr_resource_entry *res;
2320 struct scsi_device *sdev;
2321 struct ipr_dump *dump;
c4028958
DH		 2322 struct ipr_ioa_cfg *ioa_cfg =
2323 container_of(work, struct ipr_ioa_cfg, work_q);
1da177e4
LT		 2324 u8 bus, target, lun;
2325 int did_work;
2326
2327 ENTER;
2328 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2329
2330 if (ioa_cfg->sdt_state == GET_DUMP) {
2331 dump = ioa_cfg->dump;
2332 if (!dump) {
2333 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2334 return;
2335 }
2336 kref_get(&dump->kref);
2337 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2338 ipr_get_ioa_dump(ioa_cfg, dump);
2339 kref_put(&dump->kref, ipr_release_dump);
2340
2341 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2342 if (ioa_cfg->sdt_state == DUMP_OBTAINED)
2343 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2344 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2345 return;
2346 }
2347
2348restart:
2349 do {
2350 did_work = 0;
2351 if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
2352 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2353 return;
2354 }
2355
2356 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2357 if (res->del_from_ml && res->sdev) {
2358 did_work = 1;
2359 sdev = res->sdev;
2360 if (!scsi_device_get(sdev)) {
1da177e4
LT		 2361 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
2362 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2363 scsi_remove_device(sdev);
2364 scsi_device_put(sdev);
2365 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2366 }
2367 break;
2368 }
2369 }
2370 } while(did_work);
2371
2372 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2373 if (res->add_to_ml) {
2374 bus = res->cfgte.res_addr.bus;
2375 target = res->cfgte.res_addr.target;
2376 lun = res->cfgte.res_addr.lun;
1121b794 2377 res->add_to_ml = 0;
1da177e4
LT		 2378 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2379 scsi_add_device(ioa_cfg->host, bus, target, lun);
2380 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2381 goto restart;
2382 }
2383 }
2384
2385 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
312c004d 2386 kobject_uevent(&ioa_cfg->host->shost_classdev.kobj, KOBJ_CHANGE);
1da177e4
LT		 2387 LEAVE;
2388}
2389
2390#ifdef CONFIG_SCSI_IPR_TRACE
2391/**
2392 * ipr_read_trace - Dump the adapter trace
2393 * @kobj: kobject struct
2394 * @buf: buffer
2395 * @off: offset
2396 * @count: buffer size
2397 *
2398 * Return value:
2399 * number of bytes printed to buffer
2400 **/
2401static ssize_t ipr_read_trace(struct kobject *kobj, char *buf,
2402 loff_t off, size_t count)
2403{
2404 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
2405 struct Scsi_Host *shost = class_to_shost(cdev);
2406 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2407 unsigned long lock_flags = 0;
2408 int size = IPR_TRACE_SIZE;
2409 char *src = (char *)ioa_cfg->trace;
2410
2411 if (off > size)
2412 return 0;
2413 if (off + count > size) {
2414 size -= off;
2415 count = size;
2416 }
2417
2418 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2419 memcpy(buf, &src[off], count);
2420 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2421 return count;
2422}
2423
2424static struct bin_attribute ipr_trace_attr = {
2425 .attr = {
2426 .name = "trace",
2427 .mode = S_IRUGO,
2428 },
2429 .size = 0,
2430 .read = ipr_read_trace,
2431};
2432#endif
2433
62275040
BK		 2434static const struct {
2435 enum ipr_cache_state state;
2436 char *name;
2437} cache_state [] = {
2438 { CACHE_NONE, "none" },
2439 { CACHE_DISABLED, "disabled" },
2440 { CACHE_ENABLED, "enabled" }
2441};
2442
2443/**
2444 * ipr_show_write_caching - Show the write caching attribute
2445 * @class_dev: class device struct
2446 * @buf: buffer
2447 *
2448 * Return value:
2449 * number of bytes printed to buffer
2450 **/
2451static ssize_t ipr_show_write_caching(struct class_device *class_dev, char *buf)
2452{
2453 struct Scsi_Host *shost = class_to_shost(class_dev);
2454 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2455 unsigned long lock_flags = 0;
2456 int i, len = 0;
2457
2458 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2459 for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
2460 if (cache_state[i].state == ioa_cfg->cache_state) {
2461 len = snprintf(buf, PAGE_SIZE, "%s\n", cache_state[i].name);
2462 break;
2463 }
2464 }
2465 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2466 return len;
2467}
2468
2469
2470/**
2471 * ipr_store_write_caching - Enable/disable adapter write cache
2472 * @class_dev: class_device struct
2473 * @buf: buffer
2474 * @count: buffer size
2475 *
2476 * This function will enable/disable adapter write cache.
2477 *
2478 * Return value:
2479 * count on success / other on failure
2480 **/
2481static ssize_t ipr_store_write_caching(struct class_device *class_dev,
2482 const char *buf, size_t count)
2483{
2484 struct Scsi_Host *shost = class_to_shost(class_dev);
2485 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2486 unsigned long lock_flags = 0;
2487 enum ipr_cache_state new_state = CACHE_INVALID;
2488 int i;
2489
2490 if (!capable(CAP_SYS_ADMIN))
2491 return -EACCES;
2492 if (ioa_cfg->cache_state == CACHE_NONE)
2493 return -EINVAL;
2494
2495 for (i = 0; i < ARRAY_SIZE(cache_state); i++) {
2496 if (!strncmp(cache_state[i].name, buf, strlen(cache_state[i].name))) {
2497 new_state = cache_state[i].state;
2498 break;
2499 }
2500 }
2501
2502 if (new_state != CACHE_DISABLED && new_state != CACHE_ENABLED)
2503 return -EINVAL;
2504
2505 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2506 if (ioa_cfg->cache_state == new_state) {
2507 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2508 return count;
2509 }
2510
2511 ioa_cfg->cache_state = new_state;
2512 dev_info(&ioa_cfg->pdev->dev, "%s adapter write cache.\n",
2513 new_state == CACHE_ENABLED ? "Enabling" : "Disabling");
2514 if (!ioa_cfg->in_reset_reload)
2515 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2516 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2517 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2518
2519 return count;
2520}
2521
2522static struct class_device_attribute ipr_ioa_cache_attr = {
2523 .attr = {
2524 .name = "write_cache",
2525 .mode = S_IRUGO | S_IWUSR,
2526 },
2527 .show = ipr_show_write_caching,
2528 .store = ipr_store_write_caching
2529};
2530
1da177e4
LT		 2531/**
2532 * ipr_show_fw_version - Show the firmware version
2533 * @class_dev: class device struct
2534 * @buf: buffer
2535 *
2536 * Return value:
2537 * number of bytes printed to buffer
2538 **/
2539static ssize_t ipr_show_fw_version(struct class_device *class_dev, char *buf)
2540{
2541 struct Scsi_Host *shost = class_to_shost(class_dev);
2542 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2543 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2544 unsigned long lock_flags = 0;
2545 int len;
2546
2547 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2548 len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
2549 ucode_vpd->major_release, ucode_vpd->card_type,
2550 ucode_vpd->minor_release[0],
2551 ucode_vpd->minor_release[1]);
2552 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2553 return len;
2554}
2555
2556static struct class_device_attribute ipr_fw_version_attr = {
2557 .attr = {
2558 .name = "fw_version",
2559 .mode = S_IRUGO,
2560 },
2561 .show = ipr_show_fw_version,
2562};
2563
2564/**
2565 * ipr_show_log_level - Show the adapter's error logging level
2566 * @class_dev: class device struct
2567 * @buf: buffer
2568 *
2569 * Return value:
2570 * number of bytes printed to buffer
2571 **/
2572static ssize_t ipr_show_log_level(struct class_device *class_dev, char *buf)
2573{
2574 struct Scsi_Host *shost = class_to_shost(class_dev);
2575 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2576 unsigned long lock_flags = 0;
2577 int len;
2578
2579 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2580 len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
2581 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2582 return len;
2583}
2584
2585/**
2586 * ipr_store_log_level - Change the adapter's error logging level
2587 * @class_dev: class device struct
2588 * @buf: buffer
2589 *
2590 * Return value:
2591 * number of bytes printed to buffer
2592 **/
2593static ssize_t ipr_store_log_level(struct class_device *class_dev,
2594 const char *buf, size_t count)
2595{
2596 struct Scsi_Host *shost = class_to_shost(class_dev);
2597 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2598 unsigned long lock_flags = 0;
2599
2600 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2601 ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
2602 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2603 return strlen(buf);
2604}
2605
2606static struct class_device_attribute ipr_log_level_attr = {
2607 .attr = {
2608 .name = "log_level",
2609 .mode = S_IRUGO | S_IWUSR,
2610 },
2611 .show = ipr_show_log_level,
2612 .store = ipr_store_log_level
2613};
2614
2615/**
2616 * ipr_store_diagnostics - IOA Diagnostics interface
2617 * @class_dev: class_device struct
2618 * @buf: buffer
2619 * @count: buffer size
2620 *
2621 * This function will reset the adapter and wait a reasonable
2622 * amount of time for any errors that the adapter might log.
2623 *
2624 * Return value:
2625 * count on success / other on failure
2626 **/
2627static ssize_t ipr_store_diagnostics(struct class_device *class_dev,
2628 const char *buf, size_t count)
2629{
2630 struct Scsi_Host *shost = class_to_shost(class_dev);
2631 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2632 unsigned long lock_flags = 0;
2633 int rc = count;
2634
2635 if (!capable(CAP_SYS_ADMIN))
2636 return -EACCES;
2637
1da177e4 2638 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
970ea294
BK		 2639 while(ioa_cfg->in_reset_reload) {
2640 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2641 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2642 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2643 }
2644
1da177e4
LT		 2645 ioa_cfg->errors_logged = 0;
2646 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2647
2648 if (ioa_cfg->in_reset_reload) {
2649 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2650 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2651
2652 /* Wait for a second for any errors to be logged */
2653 msleep(1000);
2654 } else {
2655 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2656 return -EIO;
2657 }
2658
2659 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2660 if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
2661 rc = -EIO;
2662 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2663
2664 return rc;
2665}
2666
2667static struct class_device_attribute ipr_diagnostics_attr = {
2668 .attr = {
2669 .name = "run_diagnostics",
2670 .mode = S_IWUSR,
2671 },
2672 .store = ipr_store_diagnostics
2673};
2674
f37eb54b
BK		 2675/**
2676 * ipr_show_adapter_state - Show the adapter's state
2677 * @class_dev: class device struct
2678 * @buf: buffer
2679 *
2680 * Return value:
2681 * number of bytes printed to buffer
2682 **/
2683static ssize_t ipr_show_adapter_state(struct class_device *class_dev, char *buf)
2684{
2685 struct Scsi_Host *shost = class_to_shost(class_dev);
2686 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2687 unsigned long lock_flags = 0;
2688 int len;
2689
2690 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2691 if (ioa_cfg->ioa_is_dead)
2692 len = snprintf(buf, PAGE_SIZE, "offline\n");
2693 else
2694 len = snprintf(buf, PAGE_SIZE, "online\n");
2695 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2696 return len;
2697}
2698
2699/**
2700 * ipr_store_adapter_state - Change adapter state
2701 * @class_dev: class_device struct
2702 * @buf: buffer
2703 * @count: buffer size
2704 *
2705 * This function will change the adapter's state.
2706 *
2707 * Return value:
2708 * count on success / other on failure
2709 **/
2710static ssize_t ipr_store_adapter_state(struct class_device *class_dev,
2711 const char *buf, size_t count)
2712{
2713 struct Scsi_Host *shost = class_to_shost(class_dev);
2714 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2715 unsigned long lock_flags;
2716 int result = count;
2717
2718 if (!capable(CAP_SYS_ADMIN))
2719 return -EACCES;
2720
2721 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2722 if (ioa_cfg->ioa_is_dead && !strncmp(buf, "online", 6)) {
2723 ioa_cfg->ioa_is_dead = 0;
2724 ioa_cfg->reset_retries = 0;
2725 ioa_cfg->in_ioa_bringdown = 0;
2726 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2727 }
2728 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2729 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2730
2731 return result;
2732}
2733
2734static struct class_device_attribute ipr_ioa_state_attr = {
2735 .attr = {
2736 .name = "state",
2737 .mode = S_IRUGO | S_IWUSR,
2738 },
2739 .show = ipr_show_adapter_state,
2740 .store = ipr_store_adapter_state
2741};
2742
1da177e4
LT		 2743/**
2744 * ipr_store_reset_adapter - Reset the adapter
2745 * @class_dev: class_device struct
2746 * @buf: buffer
2747 * @count: buffer size
2748 *
2749 * This function will reset the adapter.
2750 *
2751 * Return value:
2752 * count on success / other on failure
2753 **/
2754static ssize_t ipr_store_reset_adapter(struct class_device *class_dev,
2755 const char *buf, size_t count)
2756{
2757 struct Scsi_Host *shost = class_to_shost(class_dev);
2758 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
2759 unsigned long lock_flags;
2760 int result = count;
2761
2762 if (!capable(CAP_SYS_ADMIN))
2763 return -EACCES;
2764
2765 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2766 if (!ioa_cfg->in_reset_reload)
2767 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2768 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2769 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2770
2771 return result;
2772}
2773
2774static struct class_device_attribute ipr_ioa_reset_attr = {
2775 .attr = {
2776 .name = "reset_host",
2777 .mode = S_IWUSR,
2778 },
2779 .store = ipr_store_reset_adapter
2780};
2781
2782/**
2783 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
2784 * @buf_len: buffer length
2785 *
2786 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
2787 * list to use for microcode download
2788 *
2789 * Return value:
2790 * pointer to sglist / NULL on failure
2791 **/
2792static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
2793{
2794 int sg_size, order, bsize_elem, num_elem, i, j;
2795 struct ipr_sglist *sglist;
2796 struct scatterlist *scatterlist;
2797 struct page *page;
2798
2799 /* Get the minimum size per scatter/gather element */
2800 sg_size = buf_len / (IPR_MAX_SGLIST - 1);
2801
2802 /* Get the actual size per element */
2803 order = get_order(sg_size);
2804
2805 /* Determine the actual number of bytes per element */
2806 bsize_elem = PAGE_SIZE * (1 << order);
2807
2808 /* Determine the actual number of sg entries needed */
2809 if (buf_len % bsize_elem)
2810 num_elem = (buf_len / bsize_elem) + 1;
2811 else
2812 num_elem = buf_len / bsize_elem;
2813
2814 /* Allocate a scatter/gather list for the DMA */
0bc42e35 2815 sglist = kzalloc(sizeof(struct ipr_sglist) +
1da177e4
LT		 2816 (sizeof(struct scatterlist) * (num_elem - 1)),
2817 GFP_KERNEL);
2818
2819 if (sglist == NULL) {
2820 ipr_trace;
2821 return NULL;
2822 }
2823
1da177e4
LT		 2824 scatterlist = sglist->scatterlist;
2825
2826 sglist->order = order;
2827 sglist->num_sg = num_elem;
2828
2829 /* Allocate a bunch of sg elements */
2830 for (i = 0; i < num_elem; i++) {
2831 page = alloc_pages(GFP_KERNEL, order);
2832 if (!page) {
2833 ipr_trace;
2834
2835 /* Free up what we already allocated */
2836 for (j = i - 1; j >= 0; j--)
2837 __free_pages(scatterlist[j].page, order);
2838 kfree(sglist);
2839 return NULL;
2840 }
2841
2842 scatterlist[i].page = page;
2843 }
2844
2845 return sglist;
2846}
2847
2848/**
2849 * ipr_free_ucode_buffer - Frees a microcode download buffer
2850 * @p_dnld: scatter/gather list pointer
2851 *
2852 * Free a DMA'able ucode download buffer previously allocated with
2853 * ipr_alloc_ucode_buffer
2854 *
2855 * Return value:
2856 * nothing
2857 **/
2858static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
2859{
2860 int i;
2861
2862 for (i = 0; i < sglist->num_sg; i++)
2863 __free_pages(sglist->scatterlist[i].page, sglist->order);
2864
2865 kfree(sglist);
2866}
2867
2868/**
2869 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
2870 * @sglist: scatter/gather list pointer
2871 * @buffer: buffer pointer
2872 * @len: buffer length
2873 *
2874 * Copy a microcode image from a user buffer into a buffer allocated by
2875 * ipr_alloc_ucode_buffer
2876 *
2877 * Return value:
2878 * 0 on success / other on failure
2879 **/
2880static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
2881 u8 *buffer, u32 len)
2882{
2883 int bsize_elem, i, result = 0;
2884 struct scatterlist *scatterlist;
2885 void *kaddr;
2886
2887 /* Determine the actual number of bytes per element */
2888 bsize_elem = PAGE_SIZE * (1 << sglist->order);
2889
2890 scatterlist = sglist->scatterlist;
2891
2892 for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
2893 kaddr = kmap(scatterlist[i].page);
2894 memcpy(kaddr, buffer, bsize_elem);
2895 kunmap(scatterlist[i].page);
2896
2897 scatterlist[i].length = bsize_elem;
2898
2899 if (result != 0) {
2900 ipr_trace;
2901 return result;
2902 }
2903 }
2904
2905 if (len % bsize_elem) {
2906 kaddr = kmap(scatterlist[i].page);
2907 memcpy(kaddr, buffer, len % bsize_elem);
2908 kunmap(scatterlist[i].page);
2909
2910 scatterlist[i].length = len % bsize_elem;
2911 }
2912
2913 sglist->buffer_len = len;
2914 return result;
2915}
2916
2917/**
12baa420 2918 * ipr_build_ucode_ioadl - Build a microcode download IOADL
1da177e4
LT		 2919 * @ipr_cmd: ipr command struct
2920 * @sglist: scatter/gather list
1da177e4 2921 *
12baa420 2922 * Builds a microcode download IOA data list (IOADL).
1da177e4 2923 *
1da177e4 2924 **/
12baa420
BK		 2925static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
2926 struct ipr_sglist *sglist)
1da177e4 2927{
1da177e4
LT		 2928 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
2929 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
2930 struct scatterlist *scatterlist = sglist->scatterlist;
2931 int i;
2932
12baa420 2933 ipr_cmd->dma_use_sg = sglist->num_dma_sg;
1da177e4 2934 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
12baa420 2935 ioarcb->write_data_transfer_length = cpu_to_be32(sglist->buffer_len);
1da177e4
LT		 2936 ioarcb->write_ioadl_len =
2937 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
2938
2939 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
2940 ioadl[i].flags_and_data_len =
2941 cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
2942 ioadl[i].address =
2943 cpu_to_be32(sg_dma_address(&scatterlist[i]));
2944 }
2945
12baa420
BK		 2946 ioadl[i-1].flags_and_data_len |=
2947 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
2948}
2949
2950/**
2951 * ipr_update_ioa_ucode - Update IOA's microcode
2952 * @ioa_cfg: ioa config struct
2953 * @sglist: scatter/gather list
2954 *
2955 * Initiate an adapter reset to update the IOA's microcode
2956 *
2957 * Return value:
2958 * 0 on success / -EIO on failure
2959 **/
2960static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
2961 struct ipr_sglist *sglist)
2962{
2963 unsigned long lock_flags;
2964
2965 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
970ea294
BK		 2966 while(ioa_cfg->in_reset_reload) {
2967 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2968 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2969 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2970 }
12baa420
BK		 2971
2972 if (ioa_cfg->ucode_sglist) {
2973 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2974 dev_err(&ioa_cfg->pdev->dev,
2975 "Microcode download already in progress\n");
2976 return -EIO;
1da177e4 2977 }
12baa420
BK		 2978
2979 sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
2980 sglist->num_sg, DMA_TO_DEVICE);
2981
2982 if (!sglist->num_dma_sg) {
2983 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2984 dev_err(&ioa_cfg->pdev->dev,
2985 "Failed to map microcode download buffer!\n");
1da177e4
LT		 2986 return -EIO;
2987 }
2988
12baa420
BK		 2989 ioa_cfg->ucode_sglist = sglist;
2990 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
2991 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2992 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2993
2994 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2995 ioa_cfg->ucode_sglist = NULL;
2996 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
1da177e4
LT		 2997 return 0;
2998}
2999
3000/**
3001 * ipr_store_update_fw - Update the firmware on the adapter
3002 * @class_dev: class_device struct
3003 * @buf: buffer
3004 * @count: buffer size
3005 *
3006 * This function will update the firmware on the adapter.
3007 *
3008 * Return value:
3009 * count on success / other on failure
3010 **/
3011static ssize_t ipr_store_update_fw(struct class_device *class_dev,
3012 const char *buf, size_t count)
3013{
3014 struct Scsi_Host *shost = class_to_shost(class_dev);
3015 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3016 struct ipr_ucode_image_header *image_hdr;
3017 const struct firmware *fw_entry;
3018 struct ipr_sglist *sglist;
1da177e4
LT		 3019 char fname[100];
3020 char *src;
3021 int len, result, dnld_size;
3022
3023 if (!capable(CAP_SYS_ADMIN))
3024 return -EACCES;
3025
3026 len = snprintf(fname, 99, "%s", buf);
3027 fname[len-1] = '\0';
3028
3029 if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
3030 dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
3031 return -EIO;
3032 }
3033
3034 image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
3035
3036 if (be32_to_cpu(image_hdr->header_length) > fw_entry->size ||
3037 (ioa_cfg->vpd_cbs->page3_data.card_type &&
3038 ioa_cfg->vpd_cbs->page3_data.card_type != image_hdr->card_type)) {
3039 dev_err(&ioa_cfg->pdev->dev, "Invalid microcode buffer\n");
3040 release_firmware(fw_entry);
3041 return -EINVAL;
3042 }
3043
3044 src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
3045 dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
3046 sglist = ipr_alloc_ucode_buffer(dnld_size);
3047
3048 if (!sglist) {
3049 dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
3050 release_firmware(fw_entry);
3051 return -ENOMEM;
3052 }
3053
3054 result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
3055
3056 if (result) {
3057 dev_err(&ioa_cfg->pdev->dev,
3058 "Microcode buffer copy to DMA buffer failed\n");
12baa420 3059 goto out;
1da177e4
LT		 3060 }
3061
12baa420 3062 result = ipr_update_ioa_ucode(ioa_cfg, sglist);
1da177e4 3063
12baa420
BK		 3064 if (!result)
3065 result = count;
3066out:
1da177e4
LT		 3067 ipr_free_ucode_buffer(sglist);
3068 release_firmware(fw_entry);
12baa420 3069 return result;
1da177e4
LT		 3070}
3071
3072static struct class_device_attribute ipr_update_fw_attr = {
3073 .attr = {
3074 .name = "update_fw",
3075 .mode = S_IWUSR,
3076 },
3077 .store = ipr_store_update_fw
3078};
3079
3080static struct class_device_attribute *ipr_ioa_attrs[] = {
3081 &ipr_fw_version_attr,
3082 &ipr_log_level_attr,
3083 &ipr_diagnostics_attr,
f37eb54b 3084 &ipr_ioa_state_attr,
1da177e4
LT		 3085 &ipr_ioa_reset_attr,
3086 &ipr_update_fw_attr,
62275040 3087 &ipr_ioa_cache_attr,
1da177e4
LT		 3088 NULL,
3089};
3090
3091#ifdef CONFIG_SCSI_IPR_DUMP
3092/**
3093 * ipr_read_dump - Dump the adapter
3094 * @kobj: kobject struct
3095 * @buf: buffer
3096 * @off: offset
3097 * @count: buffer size
3098 *
3099 * Return value:
3100 * number of bytes printed to buffer
3101 **/
3102static ssize_t ipr_read_dump(struct kobject *kobj, char *buf,
3103 loff_t off, size_t count)
3104{
3105 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
3106 struct Scsi_Host *shost = class_to_shost(cdev);
3107 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3108 struct ipr_dump *dump;
3109 unsigned long lock_flags = 0;
3110 char *src;
3111 int len;
3112 size_t rc = count;
3113
3114 if (!capable(CAP_SYS_ADMIN))
3115 return -EACCES;
3116
3117 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3118 dump = ioa_cfg->dump;
3119
3120 if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
3121 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3122 return 0;
3123 }
3124 kref_get(&dump->kref);
3125 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3126
3127 if (off > dump->driver_dump.hdr.len) {
3128 kref_put(&dump->kref, ipr_release_dump);
3129 return 0;
3130 }
3131
3132 if (off + count > dump->driver_dump.hdr.len) {
3133 count = dump->driver_dump.hdr.len - off;
3134 rc = count;
3135 }
3136
3137 if (count && off < sizeof(dump->driver_dump)) {
3138 if (off + count > sizeof(dump->driver_dump))
3139 len = sizeof(dump->driver_dump) - off;
3140 else
3141 len = count;
3142 src = (u8 *)&dump->driver_dump + off;
3143 memcpy(buf, src, len);
3144 buf += len;
3145 off += len;
3146 count -= len;
3147 }
3148
3149 off -= sizeof(dump->driver_dump);
3150
3151 if (count && off < offsetof(struct ipr_ioa_dump, ioa_data)) {
3152 if (off + count > offsetof(struct ipr_ioa_dump, ioa_data))
3153 len = offsetof(struct ipr_ioa_dump, ioa_data) - off;
3154 else
3155 len = count;
3156 src = (u8 *)&dump->ioa_dump + off;
3157 memcpy(buf, src, len);
3158 buf += len;
3159 off += len;
3160 count -= len;
3161 }
3162
3163 off -= offsetof(struct ipr_ioa_dump, ioa_data);
3164
3165 while (count) {
3166 if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
3167 len = PAGE_ALIGN(off) - off;
3168 else
3169 len = count;
3170 src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
3171 src += off & ~PAGE_MASK;
3172 memcpy(buf, src, len);
3173 buf += len;
3174 off += len;
3175 count -= len;
3176 }
3177
3178 kref_put(&dump->kref, ipr_release_dump);
3179 return rc;
3180}
3181
3182/**
3183 * ipr_alloc_dump - Prepare for adapter dump
3184 * @ioa_cfg: ioa config struct
3185 *
3186 * Return value:
3187 * 0 on success / other on failure
3188 **/
3189static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
3190{
3191 struct ipr_dump *dump;
3192 unsigned long lock_flags = 0;
3193
0bc42e35 3194 dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
1da177e4
LT		 3195
3196 if (!dump) {
3197 ipr_err("Dump memory allocation failed\n");
3198 return -ENOMEM;
3199 }
3200
1da177e4
LT		 3201 kref_init(&dump->kref);
3202 dump->ioa_cfg = ioa_cfg;
3203
3204 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3205
3206 if (INACTIVE != ioa_cfg->sdt_state) {
3207 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3208 kfree(dump);
3209 return 0;
3210 }
3211
3212 ioa_cfg->dump = dump;
3213 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
3214 if (ioa_cfg->ioa_is_dead && !ioa_cfg->dump_taken) {
3215 ioa_cfg->dump_taken = 1;
3216 schedule_work(&ioa_cfg->work_q);
3217 }
3218 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3219
1da177e4
LT		 3220 return 0;
3221}
3222
3223/**
3224 * ipr_free_dump - Free adapter dump memory
3225 * @ioa_cfg: ioa config struct
3226 *
3227 * Return value:
3228 * 0 on success / other on failure
3229 **/
3230static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
3231{
3232 struct ipr_dump *dump;
3233 unsigned long lock_flags = 0;
3234
3235 ENTER;
3236
3237 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3238 dump = ioa_cfg->dump;
3239 if (!dump) {
3240 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3241 return 0;
3242 }
3243
3244 ioa_cfg->dump = NULL;
3245 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3246
3247 kref_put(&dump->kref, ipr_release_dump);
3248
3249 LEAVE;
3250 return 0;
3251}
3252
3253/**
3254 * ipr_write_dump - Setup dump state of adapter
3255 * @kobj: kobject struct
3256 * @buf: buffer
3257 * @off: offset
3258 * @count: buffer size
3259 *
3260 * Return value:
3261 * number of bytes printed to buffer
3262 **/
3263static ssize_t ipr_write_dump(struct kobject *kobj, char *buf,
3264 loff_t off, size_t count)
3265{
3266 struct class_device *cdev = container_of(kobj,struct class_device,kobj);
3267 struct Scsi_Host *shost = class_to_shost(cdev);
3268 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3269 int rc;
3270
3271 if (!capable(CAP_SYS_ADMIN))
3272 return -EACCES;
3273
3274 if (buf[0] == '1')
3275 rc = ipr_alloc_dump(ioa_cfg);
3276 else if (buf[0] == '0')
3277 rc = ipr_free_dump(ioa_cfg);
3278 else
3279 return -EINVAL;
3280
3281 if (rc)
3282 return rc;
3283 else
3284 return count;
3285}
3286
3287static struct bin_attribute ipr_dump_attr = {
3288 .attr = {
3289 .name = "dump",
3290 .mode = S_IRUSR | S_IWUSR,
3291 },
3292 .size = 0,
3293 .read = ipr_read_dump,
3294 .write = ipr_write_dump
3295};
3296#else
3297static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
3298#endif
3299
3300/**
3301 * ipr_change_queue_depth - Change the device's queue depth
3302 * @sdev: scsi device struct
3303 * @qdepth: depth to set
3304 *
3305 * Return value:
3306 * actual depth set
3307 **/
3308static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
3309{
35a39691
BK		 3310 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
3311 struct ipr_resource_entry *res;
3312 unsigned long lock_flags = 0;
3313
3314 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3315 res = (struct ipr_resource_entry *)sdev->hostdata;
3316
3317 if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
3318 qdepth = IPR_MAX_CMD_PER_ATA_LUN;
3319 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3320
1da177e4
LT		 3321 scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
3322 return sdev->queue_depth;
3323}
3324
3325/**
3326 * ipr_change_queue_type - Change the device's queue type
3327 * @dsev: scsi device struct
3328 * @tag_type: type of tags to use
3329 *
3330 * Return value:
3331 * actual queue type set
3332 **/
3333static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
3334{
3335 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
3336 struct ipr_resource_entry *res;
3337 unsigned long lock_flags = 0;
3338
3339 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3340 res = (struct ipr_resource_entry *)sdev->hostdata;
3341
3342 if (res) {
3343 if (ipr_is_gscsi(res) && sdev->tagged_supported) {
3344 /*
3345 * We don't bother quiescing the device here since the
3346 * adapter firmware does it for us.
3347 */
3348 scsi_set_tag_type(sdev, tag_type);
3349
3350 if (tag_type)
3351 scsi_activate_tcq(sdev, sdev->queue_depth);
3352 else
3353 scsi_deactivate_tcq(sdev, sdev->queue_depth);
3354 } else
3355 tag_type = 0;
3356 } else
3357 tag_type = 0;
3358
3359 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3360 return tag_type;
3361}
3362
3363/**
3364 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
3365 * @dev: device struct
3366 * @buf: buffer
3367 *
3368 * Return value:
3369 * number of bytes printed to buffer
3370 **/
10523b3b 3371static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
1da177e4
LT		 3372{
3373 struct scsi_device *sdev = to_scsi_device(dev);
3374 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
3375 struct ipr_resource_entry *res;
3376 unsigned long lock_flags = 0;
3377 ssize_t len = -ENXIO;
3378
3379 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3380 res = (struct ipr_resource_entry *)sdev->hostdata;
3381 if (res)
3382 len = snprintf(buf, PAGE_SIZE, "%08X\n", res->cfgte.res_handle);
3383 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3384 return len;
3385}
3386
3387static struct device_attribute ipr_adapter_handle_attr = {
3388 .attr = {
3389 .name = "adapter_handle",
3390 .mode = S_IRUSR,
3391 },
3392 .show = ipr_show_adapter_handle
3393};
3394
3395static struct device_attribute *ipr_dev_attrs[] = {
3396 &ipr_adapter_handle_attr,
3397 NULL,
3398};
3399
3400/**
3401 * ipr_biosparam - Return the HSC mapping
3402 * @sdev: scsi device struct
3403 * @block_device: block device pointer
3404 * @capacity: capacity of the device
3405 * @parm: Array containing returned HSC values.
3406 *
3407 * This function generates the HSC parms that fdisk uses.
3408 * We want to make sure we return something that places partitions
3409 * on 4k boundaries for best performance with the IOA.
3410 *
3411 * Return value:
3412 * 0 on success
3413 **/
3414static int ipr_biosparam(struct scsi_device *sdev,
3415 struct block_device *block_device,
3416 sector_t capacity, int *parm)
3417{
3418 int heads, sectors;
3419 sector_t cylinders;
3420
3421 heads = 128;
3422 sectors = 32;
3423
3424 cylinders = capacity;
3425 sector_div(cylinders, (128 * 32));
3426
3427 /* return result */
3428 parm[0] = heads;
3429 parm[1] = sectors;
3430 parm[2] = cylinders;
3431
3432 return 0;
3433}
3434
35a39691
BK		 3435/**
3436 * ipr_find_starget - Find target based on bus/target.
3437 * @starget: scsi target struct
3438 *
3439 * Return value:
3440 * resource entry pointer if found / NULL if not found
3441 **/
3442static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
3443{
3444 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
3445 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
3446 struct ipr_resource_entry *res;
3447
3448 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3449 if ((res->cfgte.res_addr.bus == starget->channel) &&
3450 (res->cfgte.res_addr.target == starget->id) &&
3451 (res->cfgte.res_addr.lun == 0)) {
3452 return res;
3453 }
3454 }
3455
3456 return NULL;
3457}
3458
3459static struct ata_port_info sata_port_info;
3460
3461/**
3462 * ipr_target_alloc - Prepare for commands to a SCSI target
3463 * @starget: scsi target struct
3464 *
3465 * If the device is a SATA device, this function allocates an
3466 * ATA port with libata, else it does nothing.
3467 *
3468 * Return value:
3469 * 0 on success / non-0 on failure
3470 **/
3471static int ipr_target_alloc(struct scsi_target *starget)
3472{
3473 struct Scsi_Host *shost = dev_to_shost(&starget->dev);
3474 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
3475 struct ipr_sata_port *sata_port;
3476 struct ata_port *ap;
3477 struct ipr_resource_entry *res;
3478 unsigned long lock_flags;
3479
3480 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3481 res = ipr_find_starget(starget);
3482 starget->hostdata = NULL;
3483
3484 if (res && ipr_is_gata(res)) {
3485 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3486 sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
3487 if (!sata_port)
3488 return -ENOMEM;
3489
3490 ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
3491 if (ap) {
3492 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3493 sata_port->ioa_cfg = ioa_cfg;
3494 sata_port->ap = ap;
3495 sata_port->res = res;
3496
3497 res->sata_port = sata_port;
3498 ap->private_data = sata_port;
3499 starget->hostdata = sata_port;
3500 } else {
3501 kfree(sata_port);
3502 return -ENOMEM;
3503 }
3504 }
3505 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3506
3507 return 0;
3508}
3509
3510/**
3511 * ipr_target_destroy - Destroy a SCSI target
3512 * @starget: scsi target struct
3513 *
3514 * If the device was a SATA device, this function frees the libata
3515 * ATA port, else it does nothing.
3516 *
3517 **/
3518static void ipr_target_destroy(struct scsi_target *starget)
3519{
3520 struct ipr_sata_port *sata_port = starget->hostdata;
3521
3522 if (sata_port) {
3523 starget->hostdata = NULL;
3524 ata_sas_port_destroy(sata_port->ap);
3525 kfree(sata_port);
3526 }
3527}
3528
3529/**
3530 * ipr_find_sdev - Find device based on bus/target/lun.
3531 * @sdev: scsi device struct
3532 *
3533 * Return value:
3534 * resource entry pointer if found / NULL if not found
3535 **/
3536static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
3537{
3538 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3539 struct ipr_resource_entry *res;
3540
3541 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3542 if ((res->cfgte.res_addr.bus == sdev->channel) &&
3543 (res->cfgte.res_addr.target == sdev->id) &&
3544 (res->cfgte.res_addr.lun == sdev->lun))
3545 return res;
3546 }
3547
3548 return NULL;
3549}
3550
1da177e4
LT		 3551/**
3552 * ipr_slave_destroy - Unconfigure a SCSI device
3553 * @sdev: scsi device struct
3554 *
3555 * Return value:
3556 * nothing
3557 **/
3558static void ipr_slave_destroy(struct scsi_device *sdev)
3559{
3560 struct ipr_resource_entry *res;
3561 struct ipr_ioa_cfg *ioa_cfg;
3562 unsigned long lock_flags = 0;
3563
3564 ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3565
3566 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3567 res = (struct ipr_resource_entry *) sdev->hostdata;
3568 if (res) {
35a39691
BK		 3569 if (res->sata_port)
3570 ata_port_disable(res->sata_port->ap);
1da177e4
LT		 3571 sdev->hostdata = NULL;
3572 res->sdev = NULL;
35a39691 3573 res->sata_port = NULL;
1da177e4
LT		 3574 }
3575 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3576}
3577
3578/**
3579 * ipr_slave_configure - Configure a SCSI device
3580 * @sdev: scsi device struct
3581 *
3582 * This function configures the specified scsi device.
3583 *
3584 * Return value:
3585 * 0 on success
3586 **/
3587static int ipr_slave_configure(struct scsi_device *sdev)
3588{
3589 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3590 struct ipr_resource_entry *res;
3591 unsigned long lock_flags = 0;
3592
3593 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3594 res = sdev->hostdata;
3595 if (res) {
3596 if (ipr_is_af_dasd_device(res))
3597 sdev->type = TYPE_RAID;
0726ce26 3598 if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
1da177e4 3599 sdev->scsi_level = 4;
0726ce26
BK		 3600 sdev->no_uld_attach = 1;
3601 }
1da177e4
LT		 3602 if (ipr_is_vset_device(res)) {
3603 sdev->timeout = IPR_VSET_RW_TIMEOUT;
3604 blk_queue_max_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
3605 }
e4fbf44e 3606 if (ipr_is_vset_device(res) || ipr_is_scsi_disk(res))
1da177e4 3607 sdev->allow_restart = 1;
35a39691
BK		 3608 if (ipr_is_gata(res) && res->sata_port) {
3609 scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
3610 ata_sas_slave_configure(sdev, res->sata_port->ap);
3611 } else {
3612 scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
3613 }
1da177e4
LT		 3614 }
3615 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3616 return 0;
3617}
3618
35a39691
BK		 3619/**
3620 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
3621 * @sdev: scsi device struct
3622 *
3623 * This function initializes an ATA port so that future commands
3624 * sent through queuecommand will work.
3625 *
3626 * Return value:
3627 * 0 on success
3628 **/
3629static int ipr_ata_slave_alloc(struct scsi_device *sdev)
3630{
3631 struct ipr_sata_port *sata_port = NULL;
3632 int rc = -ENXIO;
3633
3634 ENTER;
3635 if (sdev->sdev_target)
3636 sata_port = sdev->sdev_target->hostdata;
3637 if (sata_port)
3638 rc = ata_sas_port_init(sata_port->ap);
3639 if (rc)
3640 ipr_slave_destroy(sdev);
3641
3642 LEAVE;
3643 return rc;
3644}
3645
1da177e4
LT		 3646/**
3647 * ipr_slave_alloc - Prepare for commands to a device.
3648 * @sdev: scsi device struct
3649 *
3650 * This function saves a pointer to the resource entry
3651 * in the scsi device struct if the device exists. We
3652 * can then use this pointer in ipr_queuecommand when
3653 * handling new commands.
3654 *
3655 * Return value:
692aebfc 3656 * 0 on success / -ENXIO if device does not exist
1da177e4
LT		 3657 **/
3658static int ipr_slave_alloc(struct scsi_device *sdev)
3659{
3660 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
3661 struct ipr_resource_entry *res;
3662 unsigned long lock_flags;
692aebfc 3663 int rc = -ENXIO;
1da177e4
LT		 3664
3665 sdev->hostdata = NULL;
3666
3667 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3668
35a39691
BK		 3669 res = ipr_find_sdev(sdev);
3670 if (res) {
3671 res->sdev = sdev;
3672 res->add_to_ml = 0;
3673 res->in_erp = 0;
3674 sdev->hostdata = res;
3675 if (!ipr_is_naca_model(res))
3676 res->needs_sync_complete = 1;
3677 rc = 0;
3678 if (ipr_is_gata(res)) {
3679 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3680 return ipr_ata_slave_alloc(sdev);
1da177e4
LT		 3681 }
3682 }
3683
3684 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3685
692aebfc 3686 return rc;
1da177e4
LT		 3687}
3688
3689/**
3690 * ipr_eh_host_reset - Reset the host adapter
3691 * @scsi_cmd: scsi command struct
3692 *
3693 * Return value:
3694 * SUCCESS / FAILED
3695 **/
df0ae249 3696static int __ipr_eh_host_reset(struct scsi_cmnd * scsi_cmd)
1da177e4
LT		 3697{
3698 struct ipr_ioa_cfg *ioa_cfg;
3699 int rc;
3700
3701 ENTER;
3702 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
3703
3704 dev_err(&ioa_cfg->pdev->dev,
3705 "Adapter being reset as a result of error recovery.\n");
3706
3707 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
3708 ioa_cfg->sdt_state = GET_DUMP;
3709
3710 rc = ipr_reset_reload(ioa_cfg, IPR_SHUTDOWN_ABBREV);
3711
3712 LEAVE;
3713 return rc;
3714}
3715
df0ae249
JG		 3716static int ipr_eh_host_reset(struct scsi_cmnd * cmd)
3717{
3718 int rc;
3719
3720 spin_lock_irq(cmd->device->host->host_lock);
3721 rc = __ipr_eh_host_reset(cmd);
3722 spin_unlock_irq(cmd->device->host->host_lock);
3723
3724 return rc;
3725}
3726
c6513096
BK		 3727/**
3728 * ipr_device_reset - Reset the device
3729 * @ioa_cfg: ioa config struct
3730 * @res: resource entry struct
3731 *
3732 * This function issues a device reset to the affected device.
3733 * If the device is a SCSI device, a LUN reset will be sent
3734 * to the device first. If that does not work, a target reset
35a39691
BK		 3735 * will be sent. If the device is a SATA device, a PHY reset will
3736 * be sent.
c6513096
BK		 3737 *
3738 * Return value:
3739 * 0 on success / non-zero on failure
3740 **/
3741static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
3742 struct ipr_resource_entry *res)
3743{
3744 struct ipr_cmnd *ipr_cmd;
3745 struct ipr_ioarcb *ioarcb;
3746 struct ipr_cmd_pkt *cmd_pkt;
35a39691 3747 struct ipr_ioarcb_ata_regs *regs;
c6513096
BK		 3748 u32 ioasc;
3749
3750 ENTER;
3751 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3752 ioarcb = &ipr_cmd->ioarcb;
3753 cmd_pkt = &ioarcb->cmd_pkt;
35a39691 3754 regs = &ioarcb->add_data.u.regs;
c6513096
BK		 3755
3756 ioarcb->res_handle = res->cfgte.res_handle;
3757 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3758 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
35a39691
BK		 3759 if (ipr_is_gata(res)) {
3760 cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
3761 ioarcb->add_cmd_parms_len = cpu_to_be32(sizeof(regs->flags));
3762 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
3763 }
c6513096
BK		 3764
3765 ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
3766 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
3767 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
35a39691
BK		 3768 if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET)
3769 memcpy(&res->sata_port->ioasa, &ipr_cmd->ioasa.u.gata,
3770 sizeof(struct ipr_ioasa_gata));
c6513096
BK		 3771
3772 LEAVE;
3773 return (IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0);
3774}
3775
35a39691
BK		 3776/**
3777 * ipr_sata_reset - Reset the SATA port
3778 * @ap: SATA port to reset
3779 * @classes: class of the attached device
3780 *
3781 * This function issues a SATA phy reset to the affected ATA port.
3782 *
3783 * Return value:
3784 * 0 on success / non-zero on failure
3785 **/
120bda35
AM		 3786static int ipr_sata_reset(struct ata_port *ap, unsigned int *classes,
3787 unsigned long deadline)
35a39691
BK		 3788{
3789 struct ipr_sata_port *sata_port = ap->private_data;
3790 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
3791 struct ipr_resource_entry *res;
3792 unsigned long lock_flags = 0;
3793 int rc = -ENXIO;
3794
3795 ENTER;
3796 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
73d98ff0
BK		 3797 while(ioa_cfg->in_reset_reload) {
3798 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3799 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3800 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3801 }
3802
35a39691
BK		 3803 res = sata_port->res;
3804 if (res) {
3805 rc = ipr_device_reset(ioa_cfg, res);
3806 switch(res->cfgte.proto) {
3807 case IPR_PROTO_SATA:
3808 case IPR_PROTO_SAS_STP:
3809 *classes = ATA_DEV_ATA;
3810 break;
3811 case IPR_PROTO_SATA_ATAPI:
3812 case IPR_PROTO_SAS_STP_ATAPI:
3813 *classes = ATA_DEV_ATAPI;
3814 break;
3815 default:
3816 *classes = ATA_DEV_UNKNOWN;
3817 break;
3818 };
3819 }
3820
3821 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3822 LEAVE;
3823 return rc;
3824}
3825
1da177e4
LT		 3826/**
3827 * ipr_eh_dev_reset - Reset the device
3828 * @scsi_cmd: scsi command struct
3829 *
3830 * This function issues a device reset to the affected device.
3831 * A LUN reset will be sent to the device first. If that does
3832 * not work, a target reset will be sent.
3833 *
3834 * Return value:
3835 * SUCCESS / FAILED
3836 **/
94d0e7b8 3837static int __ipr_eh_dev_reset(struct scsi_cmnd * scsi_cmd)
1da177e4
LT		 3838{
3839 struct ipr_cmnd *ipr_cmd;
3840 struct ipr_ioa_cfg *ioa_cfg;
3841 struct ipr_resource_entry *res;
35a39691
BK		 3842 struct ata_port *ap;
3843 int rc = 0;
1da177e4
LT		 3844
3845 ENTER;
3846 ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
3847 res = scsi_cmd->device->hostdata;
3848
eeb88307 3849 if (!res)
1da177e4
LT		 3850 return FAILED;
3851
3852 /*
3853 * If we are currently going through reset/reload, return failed. This will force the
3854 * mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
3855 * reset to complete
3856 */
3857 if (ioa_cfg->in_reset_reload)
3858 return FAILED;
3859 if (ioa_cfg->ioa_is_dead)
3860 return FAILED;
3861
3862 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
3863 if (ipr_cmd->ioarcb.res_handle == res->cfgte.res_handle) {
3864 if (ipr_cmd->scsi_cmd)
3865 ipr_cmd->done = ipr_scsi_eh_done;
24d6f2b5
BK		 3866 if (ipr_cmd->qc)
3867 ipr_cmd->done = ipr_sata_eh_done;
7402ecef
BK		 3868 if (ipr_cmd->qc && !(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
3869 ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
3870 ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
3871 }
1da177e4
LT		 3872 }
3873 }
3874
3875 res->resetting_device = 1;
fb3ed3cb 3876 scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
35a39691
BK		 3877
3878 if (ipr_is_gata(res) && res->sata_port) {
3879 ap = res->sata_port->ap;
3880 spin_unlock_irq(scsi_cmd->device->host->host_lock);
3881 ata_do_eh(ap, NULL, NULL, ipr_sata_reset, NULL);
3882 spin_lock_irq(scsi_cmd->device->host->host_lock);
3883 } else
3884 rc = ipr_device_reset(ioa_cfg, res);
1da177e4
LT		 3885 res->resetting_device = 0;
3886
1da177e4 3887 LEAVE;
c6513096 3888 return (rc ? FAILED : SUCCESS);
1da177e4
LT		 3889}
3890
94d0e7b8
JG		 3891static int ipr_eh_dev_reset(struct scsi_cmnd * cmd)
3892{
3893 int rc;
3894
3895 spin_lock_irq(cmd->device->host->host_lock);
3896 rc = __ipr_eh_dev_reset(cmd);
3897 spin_unlock_irq(cmd->device->host->host_lock);
3898
3899 return rc;
3900}
3901
1da177e4
LT		 3902/**
3903 * ipr_bus_reset_done - Op done function for bus reset.
3904 * @ipr_cmd: ipr command struct
3905 *
3906 * This function is the op done function for a bus reset
3907 *
3908 * Return value:
3909 * none
3910 **/
3911static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
3912{
3913 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3914 struct ipr_resource_entry *res;
3915
3916 ENTER;
3917 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3918 if (!memcmp(&res->cfgte.res_handle, &ipr_cmd->ioarcb.res_handle,
3919 sizeof(res->cfgte.res_handle))) {
3920 scsi_report_bus_reset(ioa_cfg->host, res->cfgte.res_addr.bus);
3921 break;
3922 }
3923 }
3924
3925 /*
3926 * If abort has not completed, indicate the reset has, else call the
3927 * abort's done function to wake the sleeping eh thread
3928 */
3929 if (ipr_cmd->sibling->sibling)
3930 ipr_cmd->sibling->sibling = NULL;
3931 else
3932 ipr_cmd->sibling->done(ipr_cmd->sibling);
3933
3934 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
3935 LEAVE;
3936}
3937
3938/**
3939 * ipr_abort_timeout - An abort task has timed out
3940 * @ipr_cmd: ipr command struct
3941 *
3942 * This function handles when an abort task times out. If this
3943 * happens we issue a bus reset since we have resources tied
3944 * up that must be freed before returning to the midlayer.
3945 *
3946 * Return value:
3947 * none
3948 **/
3949static void ipr_abort_timeout(struct ipr_cmnd *ipr_cmd)
3950{
3951 struct ipr_cmnd *reset_cmd;
3952 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
3953 struct ipr_cmd_pkt *cmd_pkt;
3954 unsigned long lock_flags = 0;
3955
3956 ENTER;
3957 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3958 if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
3959 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3960 return;
3961 }
3962
fb3ed3cb 3963 sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
1da177e4
LT		 3964 reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
3965 ipr_cmd->sibling = reset_cmd;
3966 reset_cmd->sibling = ipr_cmd;
3967 reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
3968 cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
3969 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
3970 cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
3971 cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
3972
3973 ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
3974 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3975 LEAVE;
3976}
3977
3978/**
3979 * ipr_cancel_op - Cancel specified op
3980 * @scsi_cmd: scsi command struct
3981 *
3982 * This function cancels specified op.
3983 *
3984 * Return value:
3985 * SUCCESS / FAILED
3986 **/
3987static int ipr_cancel_op(struct scsi_cmnd * scsi_cmd)
3988{
3989 struct ipr_cmnd *ipr_cmd;
3990 struct ipr_ioa_cfg *ioa_cfg;
3991 struct ipr_resource_entry *res;
3992 struct ipr_cmd_pkt *cmd_pkt;
3993 u32 ioasc;
3994 int op_found = 0;
3995
3996 ENTER;
3997 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
3998 res = scsi_cmd->device->hostdata;
3999
8fa728a2
JG		 4000 /* If we are currently going through reset/reload, return failed.
4001 * This will force the mid-layer to call ipr_eh_host_reset,
4002 * which will then go to sleep and wait for the reset to complete
4003 */
4004 if (ioa_cfg->in_reset_reload || ioa_cfg->ioa_is_dead)
4005 return FAILED;
04d9768f 4006 if (!res || !ipr_is_gscsi(res))
1da177e4
LT		 4007 return FAILED;
4008
4009 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
4010 if (ipr_cmd->scsi_cmd == scsi_cmd) {
4011 ipr_cmd->done = ipr_scsi_eh_done;
4012 op_found = 1;
4013 break;
4014 }
4015 }
4016
4017 if (!op_found)
4018 return SUCCESS;
4019
4020 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4021 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
4022 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
4023 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4024 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
4025 ipr_cmd->u.sdev = scsi_cmd->device;
4026
fb3ed3cb
BK		 4027 scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
4028 scsi_cmd->cmnd[0]);
1da177e4
LT		 4029 ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
4030 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4031
4032 /*
4033 * If the abort task timed out and we sent a bus reset, we will get
4034 * one the following responses to the abort
4035 */
4036 if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
4037 ioasc = 0;
4038 ipr_trace;
4039 }
4040
4041 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
ee0a90fa
BK		 4042 if (!ipr_is_naca_model(res))
4043 res->needs_sync_complete = 1;
1da177e4
LT		 4044
4045 LEAVE;
4046 return (IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS);
4047}
4048
4049/**
4050 * ipr_eh_abort - Abort a single op
4051 * @scsi_cmd: scsi command struct
4052 *
4053 * Return value:
4054 * SUCCESS / FAILED
4055 **/
4056static int ipr_eh_abort(struct scsi_cmnd * scsi_cmd)
4057{
8fa728a2
JG		 4058 unsigned long flags;
4059 int rc;
1da177e4
LT		 4060
4061 ENTER;
1da177e4 4062
8fa728a2
JG		 4063 spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
4064 rc = ipr_cancel_op(scsi_cmd);
4065 spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
1da177e4
LT		 4066
4067 LEAVE;
8fa728a2 4068 return rc;
1da177e4
LT		 4069}
4070
4071/**
4072 * ipr_handle_other_interrupt - Handle "other" interrupts
4073 * @ioa_cfg: ioa config struct
4074 * @int_reg: interrupt register
4075 *
4076 * Return value:
4077 * IRQ_NONE / IRQ_HANDLED
4078 **/
4079static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
4080 volatile u32 int_reg)
4081{
4082 irqreturn_t rc = IRQ_HANDLED;
4083
4084 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
4085 /* Mask the interrupt */
4086 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
4087
4088 /* Clear the interrupt */
4089 writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.clr_interrupt_reg);
4090 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
4091
4092 list_del(&ioa_cfg->reset_cmd->queue);
4093 del_timer(&ioa_cfg->reset_cmd->timer);
4094 ipr_reset_ioa_job(ioa_cfg->reset_cmd);
4095 } else {
4096 if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
4097 ioa_cfg->ioa_unit_checked = 1;
4098 else
4099 dev_err(&ioa_cfg->pdev->dev,
4100 "Permanent IOA failure. 0x%08X\n", int_reg);
4101
4102 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
4103 ioa_cfg->sdt_state = GET_DUMP;
4104
4105 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
4106 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
4107 }
4108
4109 return rc;
4110}
4111
4112/**
4113 * ipr_isr - Interrupt service routine
4114 * @irq: irq number
4115 * @devp: pointer to ioa config struct
1da177e4
LT		 4116 *
4117 * Return value:
4118 * IRQ_NONE / IRQ_HANDLED
4119 **/
7d12e780 4120static irqreturn_t ipr_isr(int irq, void *devp)
1da177e4
LT		 4121{
4122 struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
4123 unsigned long lock_flags = 0;
4124 volatile u32 int_reg, int_mask_reg;
4125 u32 ioasc;
4126 u16 cmd_index;
4127 struct ipr_cmnd *ipr_cmd;
4128 irqreturn_t rc = IRQ_NONE;
4129
4130 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4131
4132 /* If interrupts are disabled, ignore the interrupt */
4133 if (!ioa_cfg->allow_interrupts) {
4134 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4135 return IRQ_NONE;
4136 }
4137
4138 int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
4139 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
4140
4141 /* If an interrupt on the adapter did not occur, ignore it */
4142 if (unlikely((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0)) {
4143 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4144 return IRQ_NONE;
4145 }
4146
4147 while (1) {
4148 ipr_cmd = NULL;
4149
4150 while ((be32_to_cpu(*ioa_cfg->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
4151 ioa_cfg->toggle_bit) {
4152
4153 cmd_index = (be32_to_cpu(*ioa_cfg->hrrq_curr) &
4154 IPR_HRRQ_REQ_RESP_HANDLE_MASK) >> IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
4155
4156 if (unlikely(cmd_index >= IPR_NUM_CMD_BLKS)) {
4157 ioa_cfg->errors_logged++;
4158 dev_err(&ioa_cfg->pdev->dev, "Invalid response handle from IOA\n");
4159
4160 if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
4161 ioa_cfg->sdt_state = GET_DUMP;
4162
4163 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
4164 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4165 return IRQ_HANDLED;
4166 }
4167
4168 ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
4169
4170 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4171
4172 ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
4173
4174 list_del(&ipr_cmd->queue);
4175 del_timer(&ipr_cmd->timer);
4176 ipr_cmd->done(ipr_cmd);
4177
4178 rc = IRQ_HANDLED;
4179
4180 if (ioa_cfg->hrrq_curr < ioa_cfg->hrrq_end) {
4181 ioa_cfg->hrrq_curr++;
4182 } else {
4183 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
4184 ioa_cfg->toggle_bit ^= 1u;
4185 }
4186 }
4187
4188 if (ipr_cmd != NULL) {
4189 /* Clear the PCI interrupt */
4190 writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg);
4191 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
4192 } else
4193 break;
4194 }
4195
4196 if (unlikely(rc == IRQ_NONE))
4197 rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
4198
4199 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4200 return rc;
4201}
4202
4203/**
4204 * ipr_build_ioadl - Build a scatter/gather list and map the buffer
4205 * @ioa_cfg: ioa config struct
4206 * @ipr_cmd: ipr command struct
4207 *
4208 * Return value:
4209 * 0 on success / -1 on failure
4210 **/
4211static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
4212 struct ipr_cmnd *ipr_cmd)
4213{
4214 int i;
4215 struct scatterlist *sglist;
4216 u32 length;
4217 u32 ioadl_flags = 0;
4218 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4219 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4220 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
4221
4222 length = scsi_cmd->request_bufflen;
4223
4224 if (length == 0)
4225 return 0;
4226
4227 if (scsi_cmd->use_sg) {
4228 ipr_cmd->dma_use_sg = pci_map_sg(ioa_cfg->pdev,
4229 scsi_cmd->request_buffer,
4230 scsi_cmd->use_sg,
4231 scsi_cmd->sc_data_direction);
4232
4233 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
4234 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
4235 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4236 ioarcb->write_data_transfer_length = cpu_to_be32(length);
4237 ioarcb->write_ioadl_len =
4238 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
4239 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
4240 ioadl_flags = IPR_IOADL_FLAGS_READ;
4241 ioarcb->read_data_transfer_length = cpu_to_be32(length);
4242 ioarcb->read_ioadl_len =
4243 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
4244 }
4245
4246 sglist = scsi_cmd->request_buffer;
4247
51b1c7e1
BK		 4248 if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->add_data.u.ioadl)) {
4249 ioadl = ioarcb->add_data.u.ioadl;
4250 ioarcb->write_ioadl_addr =
4251 cpu_to_be32(be32_to_cpu(ioarcb->ioarcb_host_pci_addr) +
4252 offsetof(struct ipr_ioarcb, add_data));
4253 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
4254 }
4255
1da177e4
LT		 4256 for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
4257 ioadl[i].flags_and_data_len =
4258 cpu_to_be32(ioadl_flags | sg_dma_len(&sglist[i]));
4259 ioadl[i].address =
4260 cpu_to_be32(sg_dma_address(&sglist[i]));
4261 }
4262
4263 if (likely(ipr_cmd->dma_use_sg)) {
4264 ioadl[i-1].flags_and_data_len |=
4265 cpu_to_be32(IPR_IOADL_FLAGS_LAST);
4266 return 0;
4267 } else
4268 dev_err(&ioa_cfg->pdev->dev, "pci_map_sg failed!\n");
4269 } else {
4270 if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
4271 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
4272 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
4273 ioarcb->write_data_transfer_length = cpu_to_be32(length);
4274 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4275 } else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
4276 ioadl_flags = IPR_IOADL_FLAGS_READ;
4277 ioarcb->read_data_transfer_length = cpu_to_be32(length);
4278 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4279 }
4280
4281 ipr_cmd->dma_handle = pci_map_single(ioa_cfg->pdev,
4282 scsi_cmd->request_buffer, length,
4283 scsi_cmd->sc_data_direction);
4284
4285 if (likely(!pci_dma_mapping_error(ipr_cmd->dma_handle))) {
51b1c7e1
BK		 4286 ioadl = ioarcb->add_data.u.ioadl;
4287 ioarcb->write_ioadl_addr =
4288 cpu_to_be32(be32_to_cpu(ioarcb->ioarcb_host_pci_addr) +
4289 offsetof(struct ipr_ioarcb, add_data));
4290 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
1da177e4
LT		 4291 ipr_cmd->dma_use_sg = 1;
4292 ioadl[0].flags_and_data_len =
4293 cpu_to_be32(ioadl_flags | length | IPR_IOADL_FLAGS_LAST);
4294 ioadl[0].address = cpu_to_be32(ipr_cmd->dma_handle);
4295 return 0;
4296 } else
4297 dev_err(&ioa_cfg->pdev->dev, "pci_map_single failed!\n");
4298 }
4299
4300 return -1;
4301}
4302
4303/**
4304 * ipr_get_task_attributes - Translate SPI Q-Tag to task attributes
4305 * @scsi_cmd: scsi command struct
4306 *
4307 * Return value:
4308 * task attributes
4309 **/
4310static u8 ipr_get_task_attributes(struct scsi_cmnd *scsi_cmd)
4311{
4312 u8 tag[2];
4313 u8 rc = IPR_FLAGS_LO_UNTAGGED_TASK;
4314
4315 if (scsi_populate_tag_msg(scsi_cmd, tag)) {
4316 switch (tag[0]) {
4317 case MSG_SIMPLE_TAG:
4318 rc = IPR_FLAGS_LO_SIMPLE_TASK;
4319 break;
4320 case MSG_HEAD_TAG:
4321 rc = IPR_FLAGS_LO_HEAD_OF_Q_TASK;
4322 break;
4323 case MSG_ORDERED_TAG:
4324 rc = IPR_FLAGS_LO_ORDERED_TASK;
4325 break;
4326 };
4327 }
4328
4329 return rc;
4330}
4331
4332/**
4333 * ipr_erp_done - Process completion of ERP for a device
4334 * @ipr_cmd: ipr command struct
4335 *
4336 * This function copies the sense buffer into the scsi_cmd
4337 * struct and pushes the scsi_done function.
4338 *
4339 * Return value:
4340 * nothing
4341 **/
4342static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
4343{
4344 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4345 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
4346 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4347 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4348
4349 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
4350 scsi_cmd->result |= (DID_ERROR << 16);
fb3ed3cb
BK		 4351 scmd_printk(KERN_ERR, scsi_cmd,
4352 "Request Sense failed with IOASC: 0x%08X\n", ioasc);
1da177e4
LT		 4353 } else {
4354 memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
4355 SCSI_SENSE_BUFFERSIZE);
4356 }
4357
4358 if (res) {
ee0a90fa
BK		 4359 if (!ipr_is_naca_model(res))
4360 res->needs_sync_complete = 1;
1da177e4
LT		 4361 res->in_erp = 0;
4362 }
4363 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
4364 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4365 scsi_cmd->scsi_done(scsi_cmd);
4366}
4367
4368/**
4369 * ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
4370 * @ipr_cmd: ipr command struct
4371 *
4372 * Return value:
4373 * none
4374 **/
4375static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
4376{
51b1c7e1
BK		 4377 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
4378 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
4379 dma_addr_t dma_addr = be32_to_cpu(ioarcb->ioarcb_host_pci_addr);
1da177e4
LT		 4380
4381 memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
4382 ioarcb->write_data_transfer_length = 0;
4383 ioarcb->read_data_transfer_length = 0;
4384 ioarcb->write_ioadl_len = 0;
4385 ioarcb->read_ioadl_len = 0;
4386 ioasa->ioasc = 0;
4387 ioasa->residual_data_len = 0;
51b1c7e1
BK		 4388 ioarcb->write_ioadl_addr =
4389 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
4390 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
1da177e4
LT		 4391}
4392
4393/**
4394 * ipr_erp_request_sense - Send request sense to a device
4395 * @ipr_cmd: ipr command struct
4396 *
4397 * This function sends a request sense to a device as a result
4398 * of a check condition.
4399 *
4400 * Return value:
4401 * nothing
4402 **/
4403static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
4404{
4405 struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
4406 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4407
4408 if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
4409 ipr_erp_done(ipr_cmd);
4410 return;
4411 }
4412
4413 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
4414
4415 cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
4416 cmd_pkt->cdb[0] = REQUEST_SENSE;
4417 cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
4418 cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
4419 cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
4420 cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
4421
4422 ipr_cmd->ioadl[0].flags_and_data_len =
4423 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | SCSI_SENSE_BUFFERSIZE);
4424 ipr_cmd->ioadl[0].address =
4425 cpu_to_be32(ipr_cmd->sense_buffer_dma);
4426
4427 ipr_cmd->ioarcb.read_ioadl_len =
4428 cpu_to_be32(sizeof(struct ipr_ioadl_desc));
4429 ipr_cmd->ioarcb.read_data_transfer_length =
4430 cpu_to_be32(SCSI_SENSE_BUFFERSIZE);
4431
4432 ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
4433 IPR_REQUEST_SENSE_TIMEOUT * 2);
4434}
4435
4436/**
4437 * ipr_erp_cancel_all - Send cancel all to a device
4438 * @ipr_cmd: ipr command struct
4439 *
4440 * This function sends a cancel all to a device to clear the
4441 * queue. If we are running TCQ on the device, QERR is set to 1,
4442 * which means all outstanding ops have been dropped on the floor.
4443 * Cancel all will return them to us.
4444 *
4445 * Return value:
4446 * nothing
4447 **/
4448static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
4449{
4450 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4451 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
4452 struct ipr_cmd_pkt *cmd_pkt;
4453
4454 res->in_erp = 1;
4455
4456 ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
4457
4458 if (!scsi_get_tag_type(scsi_cmd->device)) {
4459 ipr_erp_request_sense(ipr_cmd);
4460 return;
4461 }
4462
4463 cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
4464 cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
4465 cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
4466
4467 ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
4468 IPR_CANCEL_ALL_TIMEOUT);
4469}
4470
4471/**
4472 * ipr_dump_ioasa - Dump contents of IOASA
4473 * @ioa_cfg: ioa config struct
4474 * @ipr_cmd: ipr command struct
fe964d0a 4475 * @res: resource entry struct
1da177e4
LT		 4476 *
4477 * This function is invoked by the interrupt handler when ops
4478 * fail. It will log the IOASA if appropriate. Only called
4479 * for GPDD ops.
4480 *
4481 * Return value:
4482 * none
4483 **/
4484static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
fe964d0a 4485 struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
1da177e4
LT		 4486{
4487 int i;
4488 u16 data_len;
b0692dd4 4489 u32 ioasc, fd_ioasc;
1da177e4
LT		 4490 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
4491 __be32 *ioasa_data = (__be32 *)ioasa;
4492 int error_index;
4493
4494 ioasc = be32_to_cpu(ioasa->ioasc) & IPR_IOASC_IOASC_MASK;
b0692dd4 4495 fd_ioasc = be32_to_cpu(ioasa->fd_ioasc) & IPR_IOASC_IOASC_MASK;
1da177e4
LT		 4496
4497 if (0 == ioasc)
4498 return;
4499
4500 if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
4501 return;
4502
b0692dd4
BK		 4503 if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
4504 error_index = ipr_get_error(fd_ioasc);
4505 else
4506 error_index = ipr_get_error(ioasc);
1da177e4
LT		 4507
4508 if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
4509 /* Don't log an error if the IOA already logged one */
4510 if (ioasa->ilid != 0)
4511 return;
4512
cc9bd5d4
BK		 4513 if (!ipr_is_gscsi(res))
4514 return;
4515
1da177e4
LT		 4516 if (ipr_error_table[error_index].log_ioasa == 0)
4517 return;
4518 }
4519
fe964d0a 4520 ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
1da177e4
LT		 4521
4522 if (sizeof(struct ipr_ioasa) < be16_to_cpu(ioasa->ret_stat_len))
4523 data_len = sizeof(struct ipr_ioasa);
4524 else
4525 data_len = be16_to_cpu(ioasa->ret_stat_len);
4526
4527 ipr_err("IOASA Dump:\n");
4528
4529 for (i = 0; i < data_len / 4; i += 4) {
4530 ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
4531 be32_to_cpu(ioasa_data[i]),
4532 be32_to_cpu(ioasa_data[i+1]),
4533 be32_to_cpu(ioasa_data[i+2]),
4534 be32_to_cpu(ioasa_data[i+3]));
4535 }
4536}
4537
4538/**
4539 * ipr_gen_sense - Generate SCSI sense data from an IOASA
4540 * @ioasa: IOASA
4541 * @sense_buf: sense data buffer
4542 *
4543 * Return value:
4544 * none
4545 **/
4546static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
4547{
4548 u32 failing_lba;
4549 u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
4550 struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
4551 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
4552 u32 ioasc = be32_to_cpu(ioasa->ioasc);
4553
4554 memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
4555
4556 if (ioasc >= IPR_FIRST_DRIVER_IOASC)
4557 return;
4558
4559 ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
4560
4561 if (ipr_is_vset_device(res) &&
4562 ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
4563 ioasa->u.vset.failing_lba_hi != 0) {
4564 sense_buf[0] = 0x72;
4565 sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
4566 sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
4567 sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
4568
4569 sense_buf[7] = 12;
4570 sense_buf[8] = 0;
4571 sense_buf[9] = 0x0A;
4572 sense_buf[10] = 0x80;
4573
4574 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
4575
4576 sense_buf[12] = (failing_lba & 0xff000000) >> 24;
4577 sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
4578 sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
4579 sense_buf[15] = failing_lba & 0x000000ff;
4580
4581 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
4582
4583 sense_buf[16] = (failing_lba & 0xff000000) >> 24;
4584 sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
4585 sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
4586 sense_buf[19] = failing_lba & 0x000000ff;
4587 } else {
4588 sense_buf[0] = 0x70;
4589 sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
4590 sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
4591 sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
4592
4593 /* Illegal request */
4594 if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
4595 (be32_to_cpu(ioasa->ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
4596 sense_buf[7] = 10; /* additional length */
4597
4598 /* IOARCB was in error */
4599 if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
4600 sense_buf[15] = 0xC0;
4601 else /* Parameter data was invalid */
4602 sense_buf[15] = 0x80;
4603
4604 sense_buf[16] =
4605 ((IPR_FIELD_POINTER_MASK &
4606 be32_to_cpu(ioasa->ioasc_specific)) >> 8) & 0xff;
4607 sense_buf[17] =
4608 (IPR_FIELD_POINTER_MASK &
4609 be32_to_cpu(ioasa->ioasc_specific)) & 0xff;
4610 } else {
4611 if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
4612 if (ipr_is_vset_device(res))
4613 failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
4614 else
4615 failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
4616
4617 sense_buf[0] |= 0x80; /* Or in the Valid bit */
4618 sense_buf[3] = (failing_lba & 0xff000000) >> 24;
4619 sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
4620 sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
4621 sense_buf[6] = failing_lba & 0x000000ff;
4622 }
4623
4624 sense_buf[7] = 6; /* additional length */
4625 }
4626 }
4627}
4628
ee0a90fa
BK		 4629/**
4630 * ipr_get_autosense - Copy autosense data to sense buffer
4631 * @ipr_cmd: ipr command struct
4632 *
4633 * This function copies the autosense buffer to the buffer
4634 * in the scsi_cmd, if there is autosense available.
4635 *
4636 * Return value:
4637 * 1 if autosense was available / 0 if not
4638 **/
4639static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
4640{
4641 struct ipr_ioasa *ioasa = &ipr_cmd->ioasa;
4642
117d2ce1 4643 if ((be32_to_cpu(ioasa->ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
ee0a90fa
BK		 4644 return 0;
4645
4646 memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
4647 min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
4648 SCSI_SENSE_BUFFERSIZE));
4649 return 1;
4650}
4651
1da177e4
LT		 4652/**
4653 * ipr_erp_start - Process an error response for a SCSI op
4654 * @ioa_cfg: ioa config struct
4655 * @ipr_cmd: ipr command struct
4656 *
4657 * This function determines whether or not to initiate ERP
4658 * on the affected device.
4659 *
4660 * Return value:
4661 * nothing
4662 **/
4663static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
4664 struct ipr_cmnd *ipr_cmd)
4665{
4666 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4667 struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
4668 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4669
4670 if (!res) {
4671 ipr_scsi_eh_done(ipr_cmd);
4672 return;
4673 }
4674
cc9bd5d4 4675 if (!ipr_is_gscsi(res))
1da177e4
LT		 4676 ipr_gen_sense(ipr_cmd);
4677
cc9bd5d4
BK		 4678 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
4679
1da177e4
LT		 4680 switch (ioasc & IPR_IOASC_IOASC_MASK) {
4681 case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
ee0a90fa
BK		 4682 if (ipr_is_naca_model(res))
4683 scsi_cmd->result |= (DID_ABORT << 16);
4684 else
4685 scsi_cmd->result |= (DID_IMM_RETRY << 16);
1da177e4
LT		 4686 break;
4687 case IPR_IOASC_IR_RESOURCE_HANDLE:
b0df54bb 4688 case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
1da177e4
LT		 4689 scsi_cmd->result |= (DID_NO_CONNECT << 16);
4690 break;
4691 case IPR_IOASC_HW_SEL_TIMEOUT:
4692 scsi_cmd->result |= (DID_NO_CONNECT << 16);
ee0a90fa
BK		 4693 if (!ipr_is_naca_model(res))
4694 res->needs_sync_complete = 1;
1da177e4
LT		 4695 break;
4696 case IPR_IOASC_SYNC_REQUIRED:
4697 if (!res->in_erp)
4698 res->needs_sync_complete = 1;
4699 scsi_cmd->result |= (DID_IMM_RETRY << 16);
4700 break;
4701 case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
b0df54bb 4702 case IPR_IOASA_IR_DUAL_IOA_DISABLED:
1da177e4
LT		 4703 scsi_cmd->result |= (DID_PASSTHROUGH << 16);
4704 break;
4705 case IPR_IOASC_BUS_WAS_RESET:
4706 case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
4707 /*
4708 * Report the bus reset and ask for a retry. The device
4709 * will give CC/UA the next command.
4710 */
4711 if (!res->resetting_device)
4712 scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
4713 scsi_cmd->result |= (DID_ERROR << 16);
ee0a90fa
BK		 4714 if (!ipr_is_naca_model(res))
4715 res->needs_sync_complete = 1;
1da177e4
LT		 4716 break;
4717 case IPR_IOASC_HW_DEV_BUS_STATUS:
4718 scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
4719 if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
ee0a90fa
BK		 4720 if (!ipr_get_autosense(ipr_cmd)) {
4721 if (!ipr_is_naca_model(res)) {
4722 ipr_erp_cancel_all(ipr_cmd);
4723 return;
4724 }
4725 }
1da177e4 4726 }
ee0a90fa
BK		 4727 if (!ipr_is_naca_model(res))
4728 res->needs_sync_complete = 1;
1da177e4
LT		 4729 break;
4730 case IPR_IOASC_NR_INIT_CMD_REQUIRED:
4731 break;
4732 default:
5b7304fb
BK		 4733 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
4734 scsi_cmd->result |= (DID_ERROR << 16);
ee0a90fa 4735 if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
1da177e4
LT		 4736 res->needs_sync_complete = 1;
4737 break;
4738 }
4739
4740 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
4741 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4742 scsi_cmd->scsi_done(scsi_cmd);
4743}
4744
4745/**
4746 * ipr_scsi_done - mid-layer done function
4747 * @ipr_cmd: ipr command struct
4748 *
4749 * This function is invoked by the interrupt handler for
4750 * ops generated by the SCSI mid-layer
4751 *
4752 * Return value:
4753 * none
4754 **/
4755static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
4756{
4757 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
4758 struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
4759 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
4760
4761 scsi_cmd->resid = be32_to_cpu(ipr_cmd->ioasa.residual_data_len);
4762
4763 if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
4764 ipr_unmap_sglist(ioa_cfg, ipr_cmd);
4765 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4766 scsi_cmd->scsi_done(scsi_cmd);
4767 } else
4768 ipr_erp_start(ioa_cfg, ipr_cmd);
4769}
4770
1da177e4
LT		 4771/**
4772 * ipr_queuecommand - Queue a mid-layer request
4773 * @scsi_cmd: scsi command struct
4774 * @done: done function
4775 *
4776 * This function queues a request generated by the mid-layer.
4777 *
4778 * Return value:
4779 * 0 on success
4780 * SCSI_MLQUEUE_DEVICE_BUSY if device is busy
4781 * SCSI_MLQUEUE_HOST_BUSY if host is busy
4782 **/
4783static int ipr_queuecommand(struct scsi_cmnd *scsi_cmd,
4784 void (*done) (struct scsi_cmnd *))
4785{
4786 struct ipr_ioa_cfg *ioa_cfg;
4787 struct ipr_resource_entry *res;
4788 struct ipr_ioarcb *ioarcb;
4789 struct ipr_cmnd *ipr_cmd;
4790 int rc = 0;
4791
4792 scsi_cmd->scsi_done = done;
4793 ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
4794 res = scsi_cmd->device->hostdata;
4795 scsi_cmd->result = (DID_OK << 16);
4796
4797 /*
4798 * We are currently blocking all devices due to a host reset
4799 * We have told the host to stop giving us new requests, but
4800 * ERP ops don't count. FIXME
4801 */
4802 if (unlikely(!ioa_cfg->allow_cmds && !ioa_cfg->ioa_is_dead))
4803 return SCSI_MLQUEUE_HOST_BUSY;
4804
4805 /*
4806 * FIXME - Create scsi_set_host_offline interface
4807 * and the ioa_is_dead check can be removed
4808 */
4809 if (unlikely(ioa_cfg->ioa_is_dead || !res)) {
4810 memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
4811 scsi_cmd->result = (DID_NO_CONNECT << 16);
4812 scsi_cmd->scsi_done(scsi_cmd);
4813 return 0;
4814 }
4815
35a39691
BK		 4816 if (ipr_is_gata(res) && res->sata_port)
4817 return ata_sas_queuecmd(scsi_cmd, done, res->sata_port->ap);
4818
1da177e4
LT		 4819 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
4820 ioarcb = &ipr_cmd->ioarcb;
4821 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
4822
4823 memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
4824 ipr_cmd->scsi_cmd = scsi_cmd;
4825 ioarcb->res_handle = res->cfgte.res_handle;
4826 ipr_cmd->done = ipr_scsi_done;
4827 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
4828
4829 if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
4830 if (scsi_cmd->underflow == 0)
4831 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
4832
4833 if (res->needs_sync_complete) {
4834 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
4835 res->needs_sync_complete = 0;
4836 }
4837
4838 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
4839 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
4840 ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
4841 ioarcb->cmd_pkt.flags_lo |= ipr_get_task_attributes(scsi_cmd);
4842 }
4843
4844 if (scsi_cmd->cmnd[0] >= 0xC0 &&
4845 (!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE))
4846 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
4847
1da177e4
LT		 4848 if (likely(rc == 0))
4849 rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
4850
4851 if (likely(rc == 0)) {
4852 mb();
4853 writel(be32_to_cpu(ipr_cmd->ioarcb.ioarcb_host_pci_addr),
4854 ioa_cfg->regs.ioarrin_reg);
4855 } else {
4856 list_move_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
4857 return SCSI_MLQUEUE_HOST_BUSY;
4858 }
4859
4860 return 0;
4861}
4862
35a39691
BK		 4863/**
4864 * ipr_ioctl - IOCTL handler
4865 * @sdev: scsi device struct
4866 * @cmd: IOCTL cmd
4867 * @arg: IOCTL arg
4868 *
4869 * Return value:
4870 * 0 on success / other on failure
4871 **/
bd705f2d 4872static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
35a39691
BK		 4873{
4874 struct ipr_resource_entry *res;
4875
4876 res = (struct ipr_resource_entry *)sdev->hostdata;
4877 if (res && ipr_is_gata(res))
4878 return ata_scsi_ioctl(sdev, cmd, arg);
4879
4880 return -EINVAL;
4881}
4882
1da177e4
LT		 4883/**
4884 * ipr_info - Get information about the card/driver
4885 * @scsi_host: scsi host struct
4886 *
4887 * Return value:
4888 * pointer to buffer with description string
4889 **/
4890static const char * ipr_ioa_info(struct Scsi_Host *host)
4891{
4892 static char buffer[512];
4893 struct ipr_ioa_cfg *ioa_cfg;
4894 unsigned long lock_flags = 0;
4895
4896 ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
4897
4898 spin_lock_irqsave(host->host_lock, lock_flags);
4899 sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
4900 spin_unlock_irqrestore(host->host_lock, lock_flags);
4901
4902 return buffer;
4903}
4904
4905static struct scsi_host_template driver_template = {
4906 .module = THIS_MODULE,
4907 .name = "IPR",
4908 .info = ipr_ioa_info,
35a39691 4909 .ioctl = ipr_ioctl,
1da177e4
LT		 4910 .queuecommand = ipr_queuecommand,
4911 .eh_abort_handler = ipr_eh_abort,
4912 .eh_device_reset_handler = ipr_eh_dev_reset,
4913 .eh_host_reset_handler = ipr_eh_host_reset,
4914 .slave_alloc = ipr_slave_alloc,
4915 .slave_configure = ipr_slave_configure,
4916 .slave_destroy = ipr_slave_destroy,
35a39691
BK		 4917 .target_alloc = ipr_target_alloc,
4918 .target_destroy = ipr_target_destroy,
1da177e4
LT		 4919 .change_queue_depth = ipr_change_queue_depth,
4920 .change_queue_type = ipr_change_queue_type,
4921 .bios_param = ipr_biosparam,
4922 .can_queue = IPR_MAX_COMMANDS,
4923 .this_id = -1,
4924 .sg_tablesize = IPR_MAX_SGLIST,
4925 .max_sectors = IPR_IOA_MAX_SECTORS,
4926 .cmd_per_lun = IPR_MAX_CMD_PER_LUN,
4927 .use_clustering = ENABLE_CLUSTERING,
4928 .shost_attrs = ipr_ioa_attrs,
4929 .sdev_attrs = ipr_dev_attrs,
4930 .proc_name = IPR_NAME
4931};
4932
35a39691
BK		 4933/**
4934 * ipr_ata_phy_reset - libata phy_reset handler
4935 * @ap: ata port to reset
4936 *
4937 **/
4938static void ipr_ata_phy_reset(struct ata_port *ap)
4939{
4940 unsigned long flags;
4941 struct ipr_sata_port *sata_port = ap->private_data;
4942 struct ipr_resource_entry *res = sata_port->res;
4943 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
4944 int rc;
4945
4946 ENTER;
4947 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
4948 while(ioa_cfg->in_reset_reload) {
4949 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
4950 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
4951 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
4952 }
4953
4954 if (!ioa_cfg->allow_cmds)
4955 goto out_unlock;
4956
4957 rc = ipr_device_reset(ioa_cfg, res);
4958
4959 if (rc) {
4960 ap->ops->port_disable(ap);
4961 goto out_unlock;
4962 }
4963
4964 switch(res->cfgte.proto) {
4965 case IPR_PROTO_SATA:
4966 case IPR_PROTO_SAS_STP:
4967 ap->device[0].class = ATA_DEV_ATA;
4968 break;
4969 case IPR_PROTO_SATA_ATAPI:
4970 case IPR_PROTO_SAS_STP_ATAPI:
4971 ap->device[0].class = ATA_DEV_ATAPI;
4972 break;
4973 default:
4974 ap->device[0].class = ATA_DEV_UNKNOWN;
4975 ap->ops->port_disable(ap);
4976 break;
4977 };
4978
4979out_unlock:
4980 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
4981 LEAVE;
4982}
4983
4984/**
4985 * ipr_ata_post_internal - Cleanup after an internal command
4986 * @qc: ATA queued command
4987 *
4988 * Return value:
4989 * none
4990 **/
4991static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
4992{
4993 struct ipr_sata_port *sata_port = qc->ap->private_data;
4994 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
4995 struct ipr_cmnd *ipr_cmd;
4996 unsigned long flags;
4997
4998 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
73d98ff0
BK		 4999 while(ioa_cfg->in_reset_reload) {
5000 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5001 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5002 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
5003 }
5004
35a39691
BK		 5005 list_for_each_entry(ipr_cmd, &ioa_cfg->pending_q, queue) {
5006 if (ipr_cmd->qc == qc) {
5007 ipr_device_reset(ioa_cfg, sata_port->res);
5008 break;
5009 }
5010 }
5011 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
5012}
5013
5014/**
5015 * ipr_tf_read - Read the current ATA taskfile for the ATA port
5016 * @ap: ATA port
5017 * @tf: destination ATA taskfile
5018 *
5019 * Return value:
5020 * none
5021 **/
5022static void ipr_tf_read(struct ata_port *ap, struct ata_taskfile *tf)
5023{
5024 struct ipr_sata_port *sata_port = ap->private_data;
5025 struct ipr_ioasa_gata *g = &sata_port->ioasa;
5026
5027 tf->feature = g->error;
5028 tf->nsect = g->nsect;
5029 tf->lbal = g->lbal;
5030 tf->lbam = g->lbam;
5031 tf->lbah = g->lbah;
5032 tf->device = g->device;
5033 tf->command = g->status;
5034 tf->hob_nsect = g->hob_nsect;
5035 tf->hob_lbal = g->hob_lbal;
5036 tf->hob_lbam = g->hob_lbam;
5037 tf->hob_lbah = g->hob_lbah;
5038 tf->ctl = g->alt_status;
5039}
5040
5041/**
5042 * ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
5043 * @regs: destination
5044 * @tf: source ATA taskfile
5045 *
5046 * Return value:
5047 * none
5048 **/
5049static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
5050 struct ata_taskfile *tf)
5051{
5052 regs->feature = tf->feature;
5053 regs->nsect = tf->nsect;
5054 regs->lbal = tf->lbal;
5055 regs->lbam = tf->lbam;
5056 regs->lbah = tf->lbah;
5057 regs->device = tf->device;
5058 regs->command = tf->command;
5059 regs->hob_feature = tf->hob_feature;
5060 regs->hob_nsect = tf->hob_nsect;
5061 regs->hob_lbal = tf->hob_lbal;
5062 regs->hob_lbam = tf->hob_lbam;
5063 regs->hob_lbah = tf->hob_lbah;
5064 regs->ctl = tf->ctl;
5065}
5066
5067/**
5068 * ipr_sata_done - done function for SATA commands
5069 * @ipr_cmd: ipr command struct
5070 *
5071 * This function is invoked by the interrupt handler for
5072 * ops generated by the SCSI mid-layer to SATA devices
5073 *
5074 * Return value:
5075 * none
5076 **/
5077static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
5078{
5079 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5080 struct ata_queued_cmd *qc = ipr_cmd->qc;
5081 struct ipr_sata_port *sata_port = qc->ap->private_data;
5082 struct ipr_resource_entry *res = sata_port->res;
5083 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
5084
5085 memcpy(&sata_port->ioasa, &ipr_cmd->ioasa.u.gata,
5086 sizeof(struct ipr_ioasa_gata));
5087 ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
5088
5089 if (be32_to_cpu(ipr_cmd->ioasa.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
5090 scsi_report_device_reset(ioa_cfg->host, res->cfgte.res_addr.bus,
5091 res->cfgte.res_addr.target);
5092
5093 if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
5094 qc->err_mask |= __ac_err_mask(ipr_cmd->ioasa.u.gata.status);
5095 else
5096 qc->err_mask |= ac_err_mask(ipr_cmd->ioasa.u.gata.status);
5097 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5098 ata_qc_complete(qc);
5099}
5100
5101/**
5102 * ipr_build_ata_ioadl - Build an ATA scatter/gather list
5103 * @ipr_cmd: ipr command struct
5104 * @qc: ATA queued command
5105 *
5106 **/
5107static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
5108 struct ata_queued_cmd *qc)
5109{
5110 u32 ioadl_flags = 0;
5111 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5112 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5113 int len = qc->nbytes + qc->pad_len;
5114 struct scatterlist *sg;
5115
5116 if (len == 0)
5117 return;
5118
5119 if (qc->dma_dir == DMA_TO_DEVICE) {
5120 ioadl_flags = IPR_IOADL_FLAGS_WRITE;
5121 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5122 ioarcb->write_data_transfer_length = cpu_to_be32(len);
5123 ioarcb->write_ioadl_len =
5124 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
5125 } else if (qc->dma_dir == DMA_FROM_DEVICE) {
5126 ioadl_flags = IPR_IOADL_FLAGS_READ;
5127 ioarcb->read_data_transfer_length = cpu_to_be32(len);
5128 ioarcb->read_ioadl_len =
5129 cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
5130 }
5131
5132 ata_for_each_sg(sg, qc) {
5133 ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
5134 ioadl->address = cpu_to_be32(sg_dma_address(sg));
5135 if (ata_sg_is_last(sg, qc))
5136 ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
5137 else
5138 ioadl++;
5139 }
5140}
5141
5142/**
5143 * ipr_qc_issue - Issue a SATA qc to a device
5144 * @qc: queued command
5145 *
5146 * Return value:
5147 * 0 if success
5148 **/
5149static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
5150{
5151 struct ata_port *ap = qc->ap;
5152 struct ipr_sata_port *sata_port = ap->private_data;
5153 struct ipr_resource_entry *res = sata_port->res;
5154 struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
5155 struct ipr_cmnd *ipr_cmd;
5156 struct ipr_ioarcb *ioarcb;
5157 struct ipr_ioarcb_ata_regs *regs;
5158
5159 if (unlikely(!ioa_cfg->allow_cmds || ioa_cfg->ioa_is_dead))
0feeed82 5160 return AC_ERR_SYSTEM;
35a39691
BK		 5161
5162 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
5163 ioarcb = &ipr_cmd->ioarcb;
5164 regs = &ioarcb->add_data.u.regs;
5165
5166 memset(&ioarcb->add_data, 0, sizeof(ioarcb->add_data));
5167 ioarcb->add_cmd_parms_len = cpu_to_be32(sizeof(ioarcb->add_data.u.regs));
5168
5169 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
5170 ipr_cmd->qc = qc;
5171 ipr_cmd->done = ipr_sata_done;
5172 ipr_cmd->ioarcb.res_handle = res->cfgte.res_handle;
5173 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
5174 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
5175 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
5176 ipr_cmd->dma_use_sg = qc->pad_len ? qc->n_elem + 1 : qc->n_elem;
5177
5178 ipr_build_ata_ioadl(ipr_cmd, qc);
5179 regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
5180 ipr_copy_sata_tf(regs, &qc->tf);
5181 memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
5182 ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_PHYS_LOC(res->cfgte.res_addr));
5183
5184 switch (qc->tf.protocol) {
5185 case ATA_PROT_NODATA:
5186 case ATA_PROT_PIO:
5187 break;
5188
5189 case ATA_PROT_DMA:
5190 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
5191 break;
5192
5193 case ATA_PROT_ATAPI:
5194 case ATA_PROT_ATAPI_NODATA:
5195 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
5196 break;
5197
5198 case ATA_PROT_ATAPI_DMA:
5199 regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
5200 regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
5201 break;
5202
5203 default:
5204 WARN_ON(1);
0feeed82 5205 return AC_ERR_INVALID;
35a39691
BK		 5206 }
5207
5208 mb();
5209 writel(be32_to_cpu(ioarcb->ioarcb_host_pci_addr),
5210 ioa_cfg->regs.ioarrin_reg);
5211 return 0;
5212}
5213
5214/**
5215 * ipr_ata_check_status - Return last ATA status
5216 * @ap: ATA port
5217 *
5218 * Return value:
5219 * ATA status
5220 **/
5221static u8 ipr_ata_check_status(struct ata_port *ap)
5222{
5223 struct ipr_sata_port *sata_port = ap->private_data;
5224 return sata_port->ioasa.status;
5225}
5226
5227/**
5228 * ipr_ata_check_altstatus - Return last ATA altstatus
5229 * @ap: ATA port
5230 *
5231 * Return value:
5232 * Alt ATA status
5233 **/
5234static u8 ipr_ata_check_altstatus(struct ata_port *ap)
5235{
5236 struct ipr_sata_port *sata_port = ap->private_data;
5237 return sata_port->ioasa.alt_status;
5238}
5239
5240static struct ata_port_operations ipr_sata_ops = {
5241 .port_disable = ata_port_disable,
5242 .check_status = ipr_ata_check_status,
5243 .check_altstatus = ipr_ata_check_altstatus,
5244 .dev_select = ata_noop_dev_select,
5245 .phy_reset = ipr_ata_phy_reset,
5246 .post_internal_cmd = ipr_ata_post_internal,
5247 .tf_read = ipr_tf_read,
5248 .qc_prep = ata_noop_qc_prep,
5249 .qc_issue = ipr_qc_issue,
5250 .port_start = ata_sas_port_start,
5251 .port_stop = ata_sas_port_stop
5252};
5253
5254static struct ata_port_info sata_port_info = {
5255 .flags = ATA_FLAG_SATA | ATA_FLAG_NO_LEGACY | ATA_FLAG_SATA_RESET |
5256 ATA_FLAG_MMIO | ATA_FLAG_PIO_DMA,
5257 .pio_mask = 0x10, /* pio4 */
5258 .mwdma_mask = 0x07,
5259 .udma_mask = 0x7f, /* udma0-6 */
5260 .port_ops = &ipr_sata_ops
5261};
5262
1da177e4
LT		 5263#ifdef CONFIG_PPC_PSERIES
5264static const u16 ipr_blocked_processors[] = {
5265 PV_NORTHSTAR,
5266 PV_PULSAR,
5267 PV_POWER4,
5268 PV_ICESTAR,
5269 PV_SSTAR,
5270 PV_POWER4p,
5271 PV_630,
5272 PV_630p
5273};
5274
5275/**
5276 * ipr_invalid_adapter - Determine if this adapter is supported on this hardware
5277 * @ioa_cfg: ioa cfg struct
5278 *
5279 * Adapters that use Gemstone revision < 3.1 do not work reliably on
5280 * certain pSeries hardware. This function determines if the given
5281 * adapter is in one of these confgurations or not.
5282 *
5283 * Return value:
5284 * 1 if adapter is not supported / 0 if adapter is supported
5285 **/
5286static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
5287{
5288 u8 rev_id;
5289 int i;
5290
5291 if (ioa_cfg->type == 0x5702) {
5292 if (pci_read_config_byte(ioa_cfg->pdev, PCI_REVISION_ID,
5293 &rev_id) == PCIBIOS_SUCCESSFUL) {
5294 if (rev_id < 4) {
5295 for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++){
5296 if (__is_processor(ipr_blocked_processors[i]))
5297 return 1;
5298 }
5299 }
5300 }
5301 }
5302 return 0;
5303}
5304#else
5305#define ipr_invalid_adapter(ioa_cfg) 0
5306#endif
5307
5308/**
5309 * ipr_ioa_bringdown_done - IOA bring down completion.
5310 * @ipr_cmd: ipr command struct
5311 *
5312 * This function processes the completion of an adapter bring down.
5313 * It wakes any reset sleepers.
5314 *
5315 * Return value:
5316 * IPR_RC_JOB_RETURN
5317 **/
5318static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
5319{
5320 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5321
5322 ENTER;
5323 ioa_cfg->in_reset_reload = 0;
5324 ioa_cfg->reset_retries = 0;
5325 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5326 wake_up_all(&ioa_cfg->reset_wait_q);
5327
5328 spin_unlock_irq(ioa_cfg->host->host_lock);
5329 scsi_unblock_requests(ioa_cfg->host);
5330 spin_lock_irq(ioa_cfg->host->host_lock);
5331 LEAVE;
5332
5333 return IPR_RC_JOB_RETURN;
5334}
5335
5336/**
5337 * ipr_ioa_reset_done - IOA reset completion.
5338 * @ipr_cmd: ipr command struct
5339 *
5340 * This function processes the completion of an adapter reset.
5341 * It schedules any necessary mid-layer add/removes and
5342 * wakes any reset sleepers.
5343 *
5344 * Return value:
5345 * IPR_RC_JOB_RETURN
5346 **/
5347static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
5348{
5349 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5350 struct ipr_resource_entry *res;
5351 struct ipr_hostrcb *hostrcb, *temp;
5352 int i = 0;
5353
5354 ENTER;
5355 ioa_cfg->in_reset_reload = 0;
5356 ioa_cfg->allow_cmds = 1;
5357 ioa_cfg->reset_cmd = NULL;
3d1d0da6 5358 ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
1da177e4
LT		 5359
5360 list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
5361 if (ioa_cfg->allow_ml_add_del && (res->add_to_ml || res->del_from_ml)) {
5362 ipr_trace;
5363 break;
5364 }
5365 }
5366 schedule_work(&ioa_cfg->work_q);
5367
5368 list_for_each_entry_safe(hostrcb, temp, &ioa_cfg->hostrcb_free_q, queue) {
5369 list_del(&hostrcb->queue);
5370 if (i++ < IPR_NUM_LOG_HCAMS)
5371 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
5372 else
5373 ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
5374 }
5375
6bb04170 5376 scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
1da177e4
LT		 5377 dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
5378
5379 ioa_cfg->reset_retries = 0;
5380 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5381 wake_up_all(&ioa_cfg->reset_wait_q);
5382
5383 spin_unlock_irq(ioa_cfg->host->host_lock);
5384 scsi_unblock_requests(ioa_cfg->host);
5385 spin_lock_irq(ioa_cfg->host->host_lock);
5386
5387 if (!ioa_cfg->allow_cmds)
5388 scsi_block_requests(ioa_cfg->host);
5389
5390 LEAVE;
5391 return IPR_RC_JOB_RETURN;
5392}
5393
5394/**
5395 * ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
5396 * @supported_dev: supported device struct
5397 * @vpids: vendor product id struct
5398 *
5399 * Return value:
5400 * none
5401 **/
5402static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
5403 struct ipr_std_inq_vpids *vpids)
5404{
5405 memset(supported_dev, 0, sizeof(struct ipr_supported_device));
5406 memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
5407 supported_dev->num_records = 1;
5408 supported_dev->data_length =
5409 cpu_to_be16(sizeof(struct ipr_supported_device));
5410 supported_dev->reserved = 0;
5411}
5412
5413/**
5414 * ipr_set_supported_devs - Send Set Supported Devices for a device
5415 * @ipr_cmd: ipr command struct
5416 *
5417 * This function send a Set Supported Devices to the adapter
5418 *
5419 * Return value:
5420 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5421 **/
5422static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
5423{
5424 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5425 struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
5426 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5427 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5428 struct ipr_resource_entry *res = ipr_cmd->u.res;
5429
5430 ipr_cmd->job_step = ipr_ioa_reset_done;
5431
5432 list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
e4fbf44e 5433 if (!ipr_is_scsi_disk(res))
1da177e4
LT		 5434 continue;
5435
5436 ipr_cmd->u.res = res;
5437 ipr_set_sup_dev_dflt(supp_dev, &res->cfgte.std_inq_data.vpids);
5438
5439 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5440 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5441 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5442
5443 ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
5444 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
5445 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
5446
5447 ioadl->flags_and_data_len = cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST |
5448 sizeof(struct ipr_supported_device));
5449 ioadl->address = cpu_to_be32(ioa_cfg->vpd_cbs_dma +
5450 offsetof(struct ipr_misc_cbs, supp_dev));
5451 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5452 ioarcb->write_data_transfer_length =
5453 cpu_to_be32(sizeof(struct ipr_supported_device));
5454
5455 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
5456 IPR_SET_SUP_DEVICE_TIMEOUT);
5457
5458 ipr_cmd->job_step = ipr_set_supported_devs;
5459 return IPR_RC_JOB_RETURN;
5460 }
5461
5462 return IPR_RC_JOB_CONTINUE;
5463}
5464
62275040
BK		 5465/**
5466 * ipr_setup_write_cache - Disable write cache if needed
5467 * @ipr_cmd: ipr command struct
5468 *
5469 * This function sets up adapters write cache to desired setting
5470 *
5471 * Return value:
5472 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5473 **/
5474static int ipr_setup_write_cache(struct ipr_cmnd *ipr_cmd)
5475{
5476 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5477
5478 ipr_cmd->job_step = ipr_set_supported_devs;
5479 ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
5480 struct ipr_resource_entry, queue);
5481
5482 if (ioa_cfg->cache_state != CACHE_DISABLED)
5483 return IPR_RC_JOB_CONTINUE;
5484
5485 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5486 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5487 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
5488 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
5489
5490 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5491
5492 return IPR_RC_JOB_RETURN;
5493}
5494
1da177e4
LT		 5495/**
5496 * ipr_get_mode_page - Locate specified mode page
5497 * @mode_pages: mode page buffer
5498 * @page_code: page code to find
5499 * @len: minimum required length for mode page
5500 *
5501 * Return value:
5502 * pointer to mode page / NULL on failure
5503 **/
5504static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
5505 u32 page_code, u32 len)
5506{
5507 struct ipr_mode_page_hdr *mode_hdr;
5508 u32 page_length;
5509 u32 length;
5510
5511 if (!mode_pages || (mode_pages->hdr.length == 0))
5512 return NULL;
5513
5514 length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
5515 mode_hdr = (struct ipr_mode_page_hdr *)
5516 (mode_pages->data + mode_pages->hdr.block_desc_len);
5517
5518 while (length) {
5519 if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
5520 if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
5521 return mode_hdr;
5522 break;
5523 } else {
5524 page_length = (sizeof(struct ipr_mode_page_hdr) +
5525 mode_hdr->page_length);
5526 length -= page_length;
5527 mode_hdr = (struct ipr_mode_page_hdr *)
5528 ((unsigned long)mode_hdr + page_length);
5529 }
5530 }
5531 return NULL;
5532}
5533
5534/**
5535 * ipr_check_term_power - Check for term power errors
5536 * @ioa_cfg: ioa config struct
5537 * @mode_pages: IOAFP mode pages buffer
5538 *
5539 * Check the IOAFP's mode page 28 for term power errors
5540 *
5541 * Return value:
5542 * nothing
5543 **/
5544static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
5545 struct ipr_mode_pages *mode_pages)
5546{
5547 int i;
5548 int entry_length;
5549 struct ipr_dev_bus_entry *bus;
5550 struct ipr_mode_page28 *mode_page;
5551
5552 mode_page = ipr_get_mode_page(mode_pages, 0x28,
5553 sizeof(struct ipr_mode_page28));
5554
5555 entry_length = mode_page->entry_length;
5556
5557 bus = mode_page->bus;
5558
5559 for (i = 0; i < mode_page->num_entries; i++) {
5560 if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
5561 dev_err(&ioa_cfg->pdev->dev,
5562 "Term power is absent on scsi bus %d\n",
5563 bus->res_addr.bus);
5564 }
5565
5566 bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
5567 }
5568}
5569
5570/**
5571 * ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
5572 * @ioa_cfg: ioa config struct
5573 *
5574 * Looks through the config table checking for SES devices. If
5575 * the SES device is in the SES table indicating a maximum SCSI
5576 * bus speed, the speed is limited for the bus.
5577 *
5578 * Return value:
5579 * none
5580 **/
5581static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
5582{
5583 u32 max_xfer_rate;
5584 int i;
5585
5586 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
5587 max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
5588 ioa_cfg->bus_attr[i].bus_width);
5589
5590 if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
5591 ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
5592 }
5593}
5594
5595/**
5596 * ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
5597 * @ioa_cfg: ioa config struct
5598 * @mode_pages: mode page 28 buffer
5599 *
5600 * Updates mode page 28 based on driver configuration
5601 *
5602 * Return value:
5603 * none
5604 **/
5605static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
5606 struct ipr_mode_pages *mode_pages)
5607{
5608 int i, entry_length;
5609 struct ipr_dev_bus_entry *bus;
5610 struct ipr_bus_attributes *bus_attr;
5611 struct ipr_mode_page28 *mode_page;
5612
5613 mode_page = ipr_get_mode_page(mode_pages, 0x28,
5614 sizeof(struct ipr_mode_page28));
5615
5616 entry_length = mode_page->entry_length;
5617
5618 /* Loop for each device bus entry */
5619 for (i = 0, bus = mode_page->bus;
5620 i < mode_page->num_entries;
5621 i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
5622 if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
5623 dev_err(&ioa_cfg->pdev->dev,
5624 "Invalid resource address reported: 0x%08X\n",
5625 IPR_GET_PHYS_LOC(bus->res_addr));
5626 continue;
5627 }
5628
5629 bus_attr = &ioa_cfg->bus_attr[i];
5630 bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
5631 bus->bus_width = bus_attr->bus_width;
5632 bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
5633 bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
5634 if (bus_attr->qas_enabled)
5635 bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
5636 else
5637 bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
5638 }
5639}
5640
5641/**
5642 * ipr_build_mode_select - Build a mode select command
5643 * @ipr_cmd: ipr command struct
5644 * @res_handle: resource handle to send command to
5645 * @parm: Byte 2 of Mode Sense command
5646 * @dma_addr: DMA buffer address
5647 * @xfer_len: data transfer length
5648 *
5649 * Return value:
5650 * none
5651 **/
5652static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
5653 __be32 res_handle, u8 parm, u32 dma_addr,
5654 u8 xfer_len)
5655{
5656 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5657 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5658
5659 ioarcb->res_handle = res_handle;
5660 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5661 ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
5662 ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
5663 ioarcb->cmd_pkt.cdb[1] = parm;
5664 ioarcb->cmd_pkt.cdb[4] = xfer_len;
5665
5666 ioadl->flags_and_data_len =
5667 cpu_to_be32(IPR_IOADL_FLAGS_WRITE_LAST | xfer_len);
5668 ioadl->address = cpu_to_be32(dma_addr);
5669 ioarcb->write_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5670 ioarcb->write_data_transfer_length = cpu_to_be32(xfer_len);
5671}
5672
5673/**
5674 * ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
5675 * @ipr_cmd: ipr command struct
5676 *
5677 * This function sets up the SCSI bus attributes and sends
5678 * a Mode Select for Page 28 to activate them.
5679 *
5680 * Return value:
5681 * IPR_RC_JOB_RETURN
5682 **/
5683static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
5684{
5685 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5686 struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
5687 int length;
5688
5689 ENTER;
4733804c
BK		 5690 ipr_scsi_bus_speed_limit(ioa_cfg);
5691 ipr_check_term_power(ioa_cfg, mode_pages);
5692 ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
5693 length = mode_pages->hdr.length + 1;
5694 mode_pages->hdr.length = 0;
1da177e4
LT		 5695
5696 ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
5697 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
5698 length);
5699
62275040 5700 ipr_cmd->job_step = ipr_setup_write_cache;
1da177e4
LT		 5701 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5702
5703 LEAVE;
5704 return IPR_RC_JOB_RETURN;
5705}
5706
5707/**
5708 * ipr_build_mode_sense - Builds a mode sense command
5709 * @ipr_cmd: ipr command struct
5710 * @res: resource entry struct
5711 * @parm: Byte 2 of mode sense command
5712 * @dma_addr: DMA address of mode sense buffer
5713 * @xfer_len: Size of DMA buffer
5714 *
5715 * Return value:
5716 * none
5717 **/
5718static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
5719 __be32 res_handle,
5720 u8 parm, u32 dma_addr, u8 xfer_len)
5721{
5722 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5723 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5724
5725 ioarcb->res_handle = res_handle;
5726 ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
5727 ioarcb->cmd_pkt.cdb[2] = parm;
5728 ioarcb->cmd_pkt.cdb[4] = xfer_len;
5729 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5730
5731 ioadl->flags_and_data_len =
5732 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
5733 ioadl->address = cpu_to_be32(dma_addr);
5734 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5735 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
5736}
5737
dfed823e
BK		 5738/**
5739 * ipr_reset_cmd_failed - Handle failure of IOA reset command
5740 * @ipr_cmd: ipr command struct
5741 *
5742 * This function handles the failure of an IOA bringup command.
5743 *
5744 * Return value:
5745 * IPR_RC_JOB_RETURN
5746 **/
5747static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
5748{
5749 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5750 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
5751
5752 dev_err(&ioa_cfg->pdev->dev,
5753 "0x%02X failed with IOASC: 0x%08X\n",
5754 ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
5755
5756 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
5757 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
5758 return IPR_RC_JOB_RETURN;
5759}
5760
5761/**
5762 * ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
5763 * @ipr_cmd: ipr command struct
5764 *
5765 * This function handles the failure of a Mode Sense to the IOAFP.
5766 * Some adapters do not handle all mode pages.
5767 *
5768 * Return value:
5769 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5770 **/
5771static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
5772{
5773 u32 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
5774
5775 if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
5776 ipr_cmd->job_step = ipr_setup_write_cache;
5777 return IPR_RC_JOB_CONTINUE;
5778 }
5779
5780 return ipr_reset_cmd_failed(ipr_cmd);
5781}
5782
1da177e4
LT		 5783/**
5784 * ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
5785 * @ipr_cmd: ipr command struct
5786 *
5787 * This function send a Page 28 mode sense to the IOA to
5788 * retrieve SCSI bus attributes.
5789 *
5790 * Return value:
5791 * IPR_RC_JOB_RETURN
5792 **/
5793static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
5794{
5795 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5796
5797 ENTER;
5798 ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
5799 0x28, ioa_cfg->vpd_cbs_dma +
5800 offsetof(struct ipr_misc_cbs, mode_pages),
5801 sizeof(struct ipr_mode_pages));
5802
5803 ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
dfed823e 5804 ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
1da177e4
LT		 5805
5806 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5807
5808 LEAVE;
5809 return IPR_RC_JOB_RETURN;
5810}
5811
5812/**
5813 * ipr_init_res_table - Initialize the resource table
5814 * @ipr_cmd: ipr command struct
5815 *
5816 * This function looks through the existing resource table, comparing
5817 * it with the config table. This function will take care of old/new
5818 * devices and schedule adding/removing them from the mid-layer
5819 * as appropriate.
5820 *
5821 * Return value:
5822 * IPR_RC_JOB_CONTINUE
5823 **/
5824static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
5825{
5826 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5827 struct ipr_resource_entry *res, *temp;
5828 struct ipr_config_table_entry *cfgte;
5829 int found, i;
5830 LIST_HEAD(old_res);
5831
5832 ENTER;
5833 if (ioa_cfg->cfg_table->hdr.flags & IPR_UCODE_DOWNLOAD_REQ)
5834 dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
5835
5836 list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
5837 list_move_tail(&res->queue, &old_res);
5838
5839 for (i = 0; i < ioa_cfg->cfg_table->hdr.num_entries; i++) {
5840 cfgte = &ioa_cfg->cfg_table->dev[i];
5841 found = 0;
5842
5843 list_for_each_entry_safe(res, temp, &old_res, queue) {
5844 if (!memcmp(&res->cfgte.res_addr,
5845 &cfgte->res_addr, sizeof(cfgte->res_addr))) {
5846 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
5847 found = 1;
5848 break;
5849 }
5850 }
5851
5852 if (!found) {
5853 if (list_empty(&ioa_cfg->free_res_q)) {
5854 dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
5855 break;
5856 }
5857
5858 found = 1;
5859 res = list_entry(ioa_cfg->free_res_q.next,
5860 struct ipr_resource_entry, queue);
5861 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
5862 ipr_init_res_entry(res);
5863 res->add_to_ml = 1;
5864 }
5865
5866 if (found)
5867 memcpy(&res->cfgte, cfgte, sizeof(struct ipr_config_table_entry));
5868 }
5869
5870 list_for_each_entry_safe(res, temp, &old_res, queue) {
5871 if (res->sdev) {
5872 res->del_from_ml = 1;
1121b794 5873 res->cfgte.res_handle = IPR_INVALID_RES_HANDLE;
1da177e4
LT		 5874 list_move_tail(&res->queue, &ioa_cfg->used_res_q);
5875 } else {
5876 list_move_tail(&res->queue, &ioa_cfg->free_res_q);
5877 }
5878 }
5879
5880 ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
5881
5882 LEAVE;
5883 return IPR_RC_JOB_CONTINUE;
5884}
5885
5886/**
5887 * ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
5888 * @ipr_cmd: ipr command struct
5889 *
5890 * This function sends a Query IOA Configuration command
5891 * to the adapter to retrieve the IOA configuration table.
5892 *
5893 * Return value:
5894 * IPR_RC_JOB_RETURN
5895 **/
5896static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
5897{
5898 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5899 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5900 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5901 struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
5902
5903 ENTER;
5904 dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
5905 ucode_vpd->major_release, ucode_vpd->card_type,
5906 ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
5907 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
5908 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5909
5910 ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
5911 ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_config_table) >> 8) & 0xff;
5912 ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_config_table) & 0xff;
5913
5914 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5915 ioarcb->read_data_transfer_length =
5916 cpu_to_be32(sizeof(struct ipr_config_table));
5917
5918 ioadl->address = cpu_to_be32(ioa_cfg->cfg_table_dma);
5919 ioadl->flags_and_data_len =
5920 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | sizeof(struct ipr_config_table));
5921
5922 ipr_cmd->job_step = ipr_init_res_table;
5923
5924 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5925
5926 LEAVE;
5927 return IPR_RC_JOB_RETURN;
5928}
5929
5930/**
5931 * ipr_ioafp_inquiry - Send an Inquiry to the adapter.
5932 * @ipr_cmd: ipr command struct
5933 *
5934 * This utility function sends an inquiry to the adapter.
5935 *
5936 * Return value:
5937 * none
5938 **/
5939static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
5940 u32 dma_addr, u8 xfer_len)
5941{
5942 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
5943 struct ipr_ioadl_desc *ioadl = ipr_cmd->ioadl;
5944
5945 ENTER;
5946 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
5947 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
5948
5949 ioarcb->cmd_pkt.cdb[0] = INQUIRY;
5950 ioarcb->cmd_pkt.cdb[1] = flags;
5951 ioarcb->cmd_pkt.cdb[2] = page;
5952 ioarcb->cmd_pkt.cdb[4] = xfer_len;
5953
5954 ioarcb->read_ioadl_len = cpu_to_be32(sizeof(struct ipr_ioadl_desc));
5955 ioarcb->read_data_transfer_length = cpu_to_be32(xfer_len);
5956
5957 ioadl->address = cpu_to_be32(dma_addr);
5958 ioadl->flags_and_data_len =
5959 cpu_to_be32(IPR_IOADL_FLAGS_READ_LAST | xfer_len);
5960
5961 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
5962 LEAVE;
5963}
5964
62275040
BK		 5965/**
5966 * ipr_inquiry_page_supported - Is the given inquiry page supported
5967 * @page0: inquiry page 0 buffer
5968 * @page: page code.
5969 *
5970 * This function determines if the specified inquiry page is supported.
5971 *
5972 * Return value:
5973 * 1 if page is supported / 0 if not
5974 **/
5975static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
5976{
5977 int i;
5978
5979 for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
5980 if (page0->page[i] == page)
5981 return 1;
5982
5983 return 0;
5984}
5985
1da177e4
LT		 5986/**
5987 * ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
5988 * @ipr_cmd: ipr command struct
5989 *
5990 * This function sends a Page 3 inquiry to the adapter
5991 * to retrieve software VPD information.
5992 *
5993 * Return value:
5994 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
5995 **/
5996static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
62275040
BK		 5997{
5998 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
5999 struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
6000
6001 ENTER;
6002
6003 if (!ipr_inquiry_page_supported(page0, 1))
6004 ioa_cfg->cache_state = CACHE_NONE;
6005
6006 ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
6007
6008 ipr_ioafp_inquiry(ipr_cmd, 1, 3,
6009 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
6010 sizeof(struct ipr_inquiry_page3));
6011
6012 LEAVE;
6013 return IPR_RC_JOB_RETURN;
6014}
6015
6016/**
6017 * ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
6018 * @ipr_cmd: ipr command struct
6019 *
6020 * This function sends a Page 0 inquiry to the adapter
6021 * to retrieve supported inquiry pages.
6022 *
6023 * Return value:
6024 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6025 **/
6026static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
1da177e4
LT		 6027{
6028 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6029 char type[5];
6030
6031 ENTER;
6032
6033 /* Grab the type out of the VPD and store it away */
6034 memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
6035 type[4] = '\0';
6036 ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
6037
62275040 6038 ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
1da177e4 6039
62275040
BK		 6040 ipr_ioafp_inquiry(ipr_cmd, 1, 0,
6041 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
6042 sizeof(struct ipr_inquiry_page0));
1da177e4
LT		 6043
6044 LEAVE;
6045 return IPR_RC_JOB_RETURN;
6046}
6047
6048/**
6049 * ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
6050 * @ipr_cmd: ipr command struct
6051 *
6052 * This function sends a standard inquiry to the adapter.
6053 *
6054 * Return value:
6055 * IPR_RC_JOB_RETURN
6056 **/
6057static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
6058{
6059 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6060
6061 ENTER;
62275040 6062 ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
1da177e4
LT		 6063
6064 ipr_ioafp_inquiry(ipr_cmd, 0, 0,
6065 ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
6066 sizeof(struct ipr_ioa_vpd));
6067
6068 LEAVE;
6069 return IPR_RC_JOB_RETURN;
6070}
6071
6072/**
6073 * ipr_ioafp_indentify_hrrq - Send Identify Host RRQ.
6074 * @ipr_cmd: ipr command struct
6075 *
6076 * This function send an Identify Host Request Response Queue
6077 * command to establish the HRRQ with the adapter.
6078 *
6079 * Return value:
6080 * IPR_RC_JOB_RETURN
6081 **/
6082static int ipr_ioafp_indentify_hrrq(struct ipr_cmnd *ipr_cmd)
6083{
6084 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6085 struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
6086
6087 ENTER;
6088 dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
6089
6090 ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
6091 ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
6092
6093 ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
6094 ioarcb->cmd_pkt.cdb[2] =
6095 ((u32) ioa_cfg->host_rrq_dma >> 24) & 0xff;
6096 ioarcb->cmd_pkt.cdb[3] =
6097 ((u32) ioa_cfg->host_rrq_dma >> 16) & 0xff;
6098 ioarcb->cmd_pkt.cdb[4] =
6099 ((u32) ioa_cfg->host_rrq_dma >> 8) & 0xff;
6100 ioarcb->cmd_pkt.cdb[5] =
6101 ((u32) ioa_cfg->host_rrq_dma) & 0xff;
6102 ioarcb->cmd_pkt.cdb[7] =
6103 ((sizeof(u32) * IPR_NUM_CMD_BLKS) >> 8) & 0xff;
6104 ioarcb->cmd_pkt.cdb[8] =
6105 (sizeof(u32) * IPR_NUM_CMD_BLKS) & 0xff;
6106
6107 ipr_cmd->job_step = ipr_ioafp_std_inquiry;
6108
6109 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
6110
6111 LEAVE;
6112 return IPR_RC_JOB_RETURN;
6113}
6114
6115/**
6116 * ipr_reset_timer_done - Adapter reset timer function
6117 * @ipr_cmd: ipr command struct
6118 *
6119 * Description: This function is used in adapter reset processing
6120 * for timing events. If the reset_cmd pointer in the IOA
6121 * config struct is not this adapter's we are doing nested
6122 * resets and fail_all_ops will take care of freeing the
6123 * command block.
6124 *
6125 * Return value:
6126 * none
6127 **/
6128static void ipr_reset_timer_done(struct ipr_cmnd *ipr_cmd)
6129{
6130 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6131 unsigned long lock_flags = 0;
6132
6133 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
6134
6135 if (ioa_cfg->reset_cmd == ipr_cmd) {
6136 list_del(&ipr_cmd->queue);
6137 ipr_cmd->done(ipr_cmd);
6138 }
6139
6140 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
6141}
6142
6143/**
6144 * ipr_reset_start_timer - Start a timer for adapter reset job
6145 * @ipr_cmd: ipr command struct
6146 * @timeout: timeout value
6147 *
6148 * Description: This function is used in adapter reset processing
6149 * for timing events. If the reset_cmd pointer in the IOA
6150 * config struct is not this adapter's we are doing nested
6151 * resets and fail_all_ops will take care of freeing the
6152 * command block.
6153 *
6154 * Return value:
6155 * none
6156 **/
6157static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
6158 unsigned long timeout)
6159{
6160 list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->pending_q);
6161 ipr_cmd->done = ipr_reset_ioa_job;
6162
6163 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
6164 ipr_cmd->timer.expires = jiffies + timeout;
6165 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_reset_timer_done;
6166 add_timer(&ipr_cmd->timer);
6167}
6168
6169/**
6170 * ipr_init_ioa_mem - Initialize ioa_cfg control block
6171 * @ioa_cfg: ioa cfg struct
6172 *
6173 * Return value:
6174 * nothing
6175 **/
6176static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
6177{
6178 memset(ioa_cfg->host_rrq, 0, sizeof(u32) * IPR_NUM_CMD_BLKS);
6179
6180 /* Initialize Host RRQ pointers */
6181 ioa_cfg->hrrq_start = ioa_cfg->host_rrq;
6182 ioa_cfg->hrrq_end = &ioa_cfg->host_rrq[IPR_NUM_CMD_BLKS - 1];
6183 ioa_cfg->hrrq_curr = ioa_cfg->hrrq_start;
6184 ioa_cfg->toggle_bit = 1;
6185
6186 /* Zero out config table */
6187 memset(ioa_cfg->cfg_table, 0, sizeof(struct ipr_config_table));
6188}
6189
6190/**
6191 * ipr_reset_enable_ioa - Enable the IOA following a reset.
6192 * @ipr_cmd: ipr command struct
6193 *
6194 * This function reinitializes some control blocks and
6195 * enables destructive diagnostics on the adapter.
6196 *
6197 * Return value:
6198 * IPR_RC_JOB_RETURN
6199 **/
6200static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
6201{
6202 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6203 volatile u32 int_reg;
6204
6205 ENTER;
6206 ipr_cmd->job_step = ipr_ioafp_indentify_hrrq;
6207 ipr_init_ioa_mem(ioa_cfg);
6208
6209 ioa_cfg->allow_interrupts = 1;
6210 int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
6211
6212 if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
6213 writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
6214 ioa_cfg->regs.clr_interrupt_mask_reg);
6215 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
6216 return IPR_RC_JOB_CONTINUE;
6217 }
6218
6219 /* Enable destructive diagnostics on IOA */
3d1d0da6 6220 writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg);
1da177e4
LT		 6221
6222 writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg);
6223 int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
6224
6225 dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
6226
6227 ipr_cmd->timer.data = (unsigned long) ipr_cmd;
5469cb5b 6228 ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
1da177e4
LT		 6229 ipr_cmd->timer.function = (void (*)(unsigned long))ipr_oper_timeout;
6230 ipr_cmd->done = ipr_reset_ioa_job;
6231 add_timer(&ipr_cmd->timer);
6232 list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
6233
6234 LEAVE;
6235 return IPR_RC_JOB_RETURN;
6236}
6237
6238/**
6239 * ipr_reset_wait_for_dump - Wait for a dump to timeout.
6240 * @ipr_cmd: ipr command struct
6241 *
6242 * This function is invoked when an adapter dump has run out
6243 * of processing time.
6244 *
6245 * Return value:
6246 * IPR_RC_JOB_CONTINUE
6247 **/
6248static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
6249{
6250 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6251
6252 if (ioa_cfg->sdt_state == GET_DUMP)
6253 ioa_cfg->sdt_state = ABORT_DUMP;
6254
6255 ipr_cmd->job_step = ipr_reset_alert;
6256
6257 return IPR_RC_JOB_CONTINUE;
6258}
6259
6260/**
6261 * ipr_unit_check_no_data - Log a unit check/no data error log
6262 * @ioa_cfg: ioa config struct
6263 *
6264 * Logs an error indicating the adapter unit checked, but for some
6265 * reason, we were unable to fetch the unit check buffer.
6266 *
6267 * Return value:
6268 * nothing
6269 **/
6270static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
6271{
6272 ioa_cfg->errors_logged++;
6273 dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
6274}
6275
6276/**
6277 * ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
6278 * @ioa_cfg: ioa config struct
6279 *
6280 * Fetches the unit check buffer from the adapter by clocking the data
6281 * through the mailbox register.
6282 *
6283 * Return value:
6284 * nothing
6285 **/
6286static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
6287{
6288 unsigned long mailbox;
6289 struct ipr_hostrcb *hostrcb;
6290 struct ipr_uc_sdt sdt;
6291 int rc, length;
6292
6293 mailbox = readl(ioa_cfg->ioa_mailbox);
6294
6295 if (!ipr_sdt_is_fmt2(mailbox)) {
6296 ipr_unit_check_no_data(ioa_cfg);
6297 return;
6298 }
6299
6300 memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
6301 rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
6302 (sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
6303
6304 if (rc || (be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE) ||
6305 !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY)) {
6306 ipr_unit_check_no_data(ioa_cfg);
6307 return;
6308 }
6309
6310 /* Find length of the first sdt entry (UC buffer) */
6311 length = (be32_to_cpu(sdt.entry[0].end_offset) -
6312 be32_to_cpu(sdt.entry[0].bar_str_offset)) & IPR_FMT2_MBX_ADDR_MASK;
6313
6314 hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
6315 struct ipr_hostrcb, queue);
6316 list_del(&hostrcb->queue);
6317 memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
6318
6319 rc = ipr_get_ldump_data_section(ioa_cfg,
6320 be32_to_cpu(sdt.entry[0].bar_str_offset),
6321 (__be32 *)&hostrcb->hcam,
6322 min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
6323
6324 if (!rc)
6325 ipr_handle_log_data(ioa_cfg, hostrcb);
6326 else
6327 ipr_unit_check_no_data(ioa_cfg);
6328
6329 list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
6330}
6331
6332/**
6333 * ipr_reset_restore_cfg_space - Restore PCI config space.
6334 * @ipr_cmd: ipr command struct
6335 *
6336 * Description: This function restores the saved PCI config space of
6337 * the adapter, fails all outstanding ops back to the callers, and
6338 * fetches the dump/unit check if applicable to this reset.
6339 *
6340 * Return value:
6341 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6342 **/
6343static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
6344{
6345 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6346 int rc;
6347
6348 ENTER;
6349 rc = pci_restore_state(ioa_cfg->pdev);
6350
6351 if (rc != PCIBIOS_SUCCESSFUL) {
6352 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
6353 return IPR_RC_JOB_CONTINUE;
6354 }
6355
6356 if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
6357 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
6358 return IPR_RC_JOB_CONTINUE;
6359 }
6360
6361 ipr_fail_all_ops(ioa_cfg);
6362
6363 if (ioa_cfg->ioa_unit_checked) {
6364 ioa_cfg->ioa_unit_checked = 0;
6365 ipr_get_unit_check_buffer(ioa_cfg);
6366 ipr_cmd->job_step = ipr_reset_alert;
6367 ipr_reset_start_timer(ipr_cmd, 0);
6368 return IPR_RC_JOB_RETURN;
6369 }
6370
6371 if (ioa_cfg->in_ioa_bringdown) {
6372 ipr_cmd->job_step = ipr_ioa_bringdown_done;
6373 } else {
6374 ipr_cmd->job_step = ipr_reset_enable_ioa;
6375
6376 if (GET_DUMP == ioa_cfg->sdt_state) {
6377 ipr_reset_start_timer(ipr_cmd, IPR_DUMP_TIMEOUT);
6378 ipr_cmd->job_step = ipr_reset_wait_for_dump;
6379 schedule_work(&ioa_cfg->work_q);
6380 return IPR_RC_JOB_RETURN;
6381 }
6382 }
6383
6384 ENTER;
6385 return IPR_RC_JOB_CONTINUE;
6386}
6387
e619e1a7
BK		 6388/**
6389 * ipr_reset_bist_done - BIST has completed on the adapter.
6390 * @ipr_cmd: ipr command struct
6391 *
6392 * Description: Unblock config space and resume the reset process.
6393 *
6394 * Return value:
6395 * IPR_RC_JOB_CONTINUE
6396 **/
6397static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
6398{
6399 ENTER;
6400 pci_unblock_user_cfg_access(ipr_cmd->ioa_cfg->pdev);
6401 ipr_cmd->job_step = ipr_reset_restore_cfg_space;
6402 LEAVE;
6403 return IPR_RC_JOB_CONTINUE;
6404}
6405
1da177e4
LT		 6406/**
6407 * ipr_reset_start_bist - Run BIST on the adapter.
6408 * @ipr_cmd: ipr command struct
6409 *
6410 * Description: This function runs BIST on the adapter, then delays 2 seconds.
6411 *
6412 * Return value:
6413 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6414 **/
6415static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
6416{
6417 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6418 int rc;
6419
6420 ENTER;
b30197d2 6421 pci_block_user_cfg_access(ioa_cfg->pdev);
1da177e4
LT		 6422 rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
6423
6424 if (rc != PCIBIOS_SUCCESSFUL) {
a9aedb09 6425 pci_unblock_user_cfg_access(ipr_cmd->ioa_cfg->pdev);
1da177e4
LT		 6426 ipr_cmd->ioasa.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
6427 rc = IPR_RC_JOB_CONTINUE;
6428 } else {
e619e1a7 6429 ipr_cmd->job_step = ipr_reset_bist_done;
1da177e4
LT		 6430 ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
6431 rc = IPR_RC_JOB_RETURN;
6432 }
6433
6434 LEAVE;
6435 return rc;
6436}
6437
6438/**
6439 * ipr_reset_allowed - Query whether or not IOA can be reset
6440 * @ioa_cfg: ioa config struct
6441 *
6442 * Return value:
6443 * 0 if reset not allowed / non-zero if reset is allowed
6444 **/
6445static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
6446{
6447 volatile u32 temp_reg;
6448
6449 temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
6450 return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
6451}
6452
6453/**
6454 * ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
6455 * @ipr_cmd: ipr command struct
6456 *
6457 * Description: This function waits for adapter permission to run BIST,
6458 * then runs BIST. If the adapter does not give permission after a
6459 * reasonable time, we will reset the adapter anyway. The impact of
6460 * resetting the adapter without warning the adapter is the risk of
6461 * losing the persistent error log on the adapter. If the adapter is
6462 * reset while it is writing to the flash on the adapter, the flash
6463 * segment will have bad ECC and be zeroed.
6464 *
6465 * Return value:
6466 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6467 **/
6468static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
6469{
6470 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6471 int rc = IPR_RC_JOB_RETURN;
6472
6473 if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
6474 ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
6475 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
6476 } else {
6477 ipr_cmd->job_step = ipr_reset_start_bist;
6478 rc = IPR_RC_JOB_CONTINUE;
6479 }
6480
6481 return rc;
6482}
6483
6484/**
6485 * ipr_reset_alert_part2 - Alert the adapter of a pending reset
6486 * @ipr_cmd: ipr command struct
6487 *
6488 * Description: This function alerts the adapter that it will be reset.
6489 * If memory space is not currently enabled, proceed directly
6490 * to running BIST on the adapter. The timer must always be started
6491 * so we guarantee we do not run BIST from ipr_isr.
6492 *
6493 * Return value:
6494 * IPR_RC_JOB_RETURN
6495 **/
6496static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
6497{
6498 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6499 u16 cmd_reg;
6500 int rc;
6501
6502 ENTER;
6503 rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
6504
6505 if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
6506 ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
6507 writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg);
6508 ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
6509 } else {
6510 ipr_cmd->job_step = ipr_reset_start_bist;
6511 }
6512
6513 ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
6514 ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
6515
6516 LEAVE;
6517 return IPR_RC_JOB_RETURN;
6518}
6519
6520/**
6521 * ipr_reset_ucode_download_done - Microcode download completion
6522 * @ipr_cmd: ipr command struct
6523 *
6524 * Description: This function unmaps the microcode download buffer.
6525 *
6526 * Return value:
6527 * IPR_RC_JOB_CONTINUE
6528 **/
6529static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
6530{
6531 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6532 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
6533
6534 pci_unmap_sg(ioa_cfg->pdev, sglist->scatterlist,
6535 sglist->num_sg, DMA_TO_DEVICE);
6536
6537 ipr_cmd->job_step = ipr_reset_alert;
6538 return IPR_RC_JOB_CONTINUE;
6539}
6540
6541/**
6542 * ipr_reset_ucode_download - Download microcode to the adapter
6543 * @ipr_cmd: ipr command struct
6544 *
6545 * Description: This function checks to see if it there is microcode
6546 * to download to the adapter. If there is, a download is performed.
6547 *
6548 * Return value:
6549 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6550 **/
6551static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
6552{
6553 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6554 struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
6555
6556 ENTER;
6557 ipr_cmd->job_step = ipr_reset_alert;
6558
6559 if (!sglist)
6560 return IPR_RC_JOB_CONTINUE;
6561
6562 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
6563 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
6564 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
6565 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
6566 ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
6567 ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
6568 ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
6569
12baa420 6570 ipr_build_ucode_ioadl(ipr_cmd, sglist);
1da177e4
LT		 6571 ipr_cmd->job_step = ipr_reset_ucode_download_done;
6572
6573 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
6574 IPR_WRITE_BUFFER_TIMEOUT);
6575
6576 LEAVE;
6577 return IPR_RC_JOB_RETURN;
6578}
6579
6580/**
6581 * ipr_reset_shutdown_ioa - Shutdown the adapter
6582 * @ipr_cmd: ipr command struct
6583 *
6584 * Description: This function issues an adapter shutdown of the
6585 * specified type to the specified adapter as part of the
6586 * adapter reset job.
6587 *
6588 * Return value:
6589 * IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
6590 **/
6591static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
6592{
6593 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6594 enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
6595 unsigned long timeout;
6596 int rc = IPR_RC_JOB_CONTINUE;
6597
6598 ENTER;
6599 if (shutdown_type != IPR_SHUTDOWN_NONE && !ioa_cfg->ioa_is_dead) {
6600 ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
6601 ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
6602 ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
6603 ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
6604
6605 if (shutdown_type == IPR_SHUTDOWN_ABBREV)
6606 timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
6607 else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
6608 timeout = IPR_INTERNAL_TIMEOUT;
6609 else
6610 timeout = IPR_SHUTDOWN_TIMEOUT;
6611
6612 ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
6613
6614 rc = IPR_RC_JOB_RETURN;
6615 ipr_cmd->job_step = ipr_reset_ucode_download;
6616 } else
6617 ipr_cmd->job_step = ipr_reset_alert;
6618
6619 LEAVE;
6620 return rc;
6621}
6622
6623/**
6624 * ipr_reset_ioa_job - Adapter reset job
6625 * @ipr_cmd: ipr command struct
6626 *
6627 * Description: This function is the job router for the adapter reset job.
6628 *
6629 * Return value:
6630 * none
6631 **/
6632static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
6633{
6634 u32 rc, ioasc;
1da177e4
LT		 6635 struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
6636
6637 do {
6638 ioasc = be32_to_cpu(ipr_cmd->ioasa.ioasc);
6639
6640 if (ioa_cfg->reset_cmd != ipr_cmd) {
6641 /*
6642 * We are doing nested adapter resets and this is
6643 * not the current reset job.
6644 */
6645 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
6646 return;
6647 }
6648
6649 if (IPR_IOASC_SENSE_KEY(ioasc)) {
dfed823e
BK		 6650 rc = ipr_cmd->job_step_failed(ipr_cmd);
6651 if (rc == IPR_RC_JOB_RETURN)
6652 return;
1da177e4
LT		 6653 }
6654
6655 ipr_reinit_ipr_cmnd(ipr_cmd);
dfed823e 6656 ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
1da177e4
LT		 6657 rc = ipr_cmd->job_step(ipr_cmd);
6658 } while(rc == IPR_RC_JOB_CONTINUE);
6659}
6660
6661/**
6662 * _ipr_initiate_ioa_reset - Initiate an adapter reset
6663 * @ioa_cfg: ioa config struct
6664 * @job_step: first job step of reset job
6665 * @shutdown_type: shutdown type
6666 *
6667 * Description: This function will initiate the reset of the given adapter
6668 * starting at the selected job step.
6669 * If the caller needs to wait on the completion of the reset,
6670 * the caller must sleep on the reset_wait_q.
6671 *
6672 * Return value:
6673 * none
6674 **/
6675static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
6676 int (*job_step) (struct ipr_cmnd *),
6677 enum ipr_shutdown_type shutdown_type)
6678{
6679 struct ipr_cmnd *ipr_cmd;
6680
6681 ioa_cfg->in_reset_reload = 1;
6682 ioa_cfg->allow_cmds = 0;
6683 scsi_block_requests(ioa_cfg->host);
6684
6685 ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
6686 ioa_cfg->reset_cmd = ipr_cmd;
6687 ipr_cmd->job_step = job_step;
6688 ipr_cmd->u.shutdown_type = shutdown_type;
6689
6690 ipr_reset_ioa_job(ipr_cmd);
6691}
6692
6693/**
6694 * ipr_initiate_ioa_reset - Initiate an adapter reset
6695 * @ioa_cfg: ioa config struct
6696 * @shutdown_type: shutdown type
6697 *
6698 * Description: This function will initiate the reset of the given adapter.
6699 * If the caller needs to wait on the completion of the reset,
6700 * the caller must sleep on the reset_wait_q.
6701 *
6702 * Return value:
6703 * none
6704 **/
6705static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
6706 enum ipr_shutdown_type shutdown_type)
6707{
6708 if (ioa_cfg->ioa_is_dead)
6709 return;
6710
6711 if (ioa_cfg->in_reset_reload && ioa_cfg->sdt_state == GET_DUMP)
6712 ioa_cfg->sdt_state = ABORT_DUMP;
6713
6714 if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
6715 dev_err(&ioa_cfg->pdev->dev,
6716 "IOA taken offline - error recovery failed\n");
6717
6718 ioa_cfg->reset_retries = 0;
6719 ioa_cfg->ioa_is_dead = 1;
6720
6721 if (ioa_cfg->in_ioa_bringdown) {
6722 ioa_cfg->reset_cmd = NULL;
6723 ioa_cfg->in_reset_reload = 0;
6724 ipr_fail_all_ops(ioa_cfg);
6725 wake_up_all(&ioa_cfg->reset_wait_q);
6726
6727 spin_unlock_irq(ioa_cfg->host->host_lock);
6728 scsi_unblock_requests(ioa_cfg->host);
6729 spin_lock_irq(ioa_cfg->host->host_lock);
6730 return;
6731 } else {
6732 ioa_cfg->in_ioa_bringdown = 1;
6733 shutdown_type = IPR_SHUTDOWN_NONE;
6734 }
6735 }
6736
6737 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
6738 shutdown_type);
6739}
6740
f8a88b19
LV		 6741/**
6742 * ipr_reset_freeze - Hold off all I/O activity
6743 * @ipr_cmd: ipr command struct
6744 *
6745 * Description: If the PCI slot is frozen, hold off all I/O
6746 * activity; then, as soon as the slot is available again,
6747 * initiate an adapter reset.
6748 */
6749static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
6750{
6751 /* Disallow new interrupts, avoid loop */
6752 ipr_cmd->ioa_cfg->allow_interrupts = 0;
6753 list_add_tail(&ipr_cmd->queue, &ipr_cmd->ioa_cfg->pending_q);
6754 ipr_cmd->done = ipr_reset_ioa_job;
6755 return IPR_RC_JOB_RETURN;
6756}
6757
6758/**
6759 * ipr_pci_frozen - Called when slot has experienced a PCI bus error.
6760 * @pdev: PCI device struct
6761 *
6762 * Description: This routine is called to tell us that the PCI bus
6763 * is down. Can't do anything here, except put the device driver
6764 * into a holding pattern, waiting for the PCI bus to come back.
6765 */
6766static void ipr_pci_frozen(struct pci_dev *pdev)
6767{
6768 unsigned long flags = 0;
6769 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6770
6771 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6772 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
6773 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6774}
6775
6776/**
6777 * ipr_pci_slot_reset - Called when PCI slot has been reset.
6778 * @pdev: PCI device struct
6779 *
6780 * Description: This routine is called by the pci error recovery
6781 * code after the PCI slot has been reset, just before we
6782 * should resume normal operations.
6783 */
6784static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
6785{
6786 unsigned long flags = 0;
6787 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6788
6789 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6790 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
6791 IPR_SHUTDOWN_NONE);
6792 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6793 return PCI_ERS_RESULT_RECOVERED;
6794}
6795
6796/**
6797 * ipr_pci_perm_failure - Called when PCI slot is dead for good.
6798 * @pdev: PCI device struct
6799 *
6800 * Description: This routine is called when the PCI bus has
6801 * permanently failed.
6802 */
6803static void ipr_pci_perm_failure(struct pci_dev *pdev)
6804{
6805 unsigned long flags = 0;
6806 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
6807
6808 spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
6809 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
6810 ioa_cfg->sdt_state = ABORT_DUMP;
6811 ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES;
6812 ioa_cfg->in_ioa_bringdown = 1;
6813 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
6814 spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
6815}
6816
6817/**
6818 * ipr_pci_error_detected - Called when a PCI error is detected.
6819 * @pdev: PCI device struct
6820 * @state: PCI channel state
6821 *
6822 * Description: Called when a PCI error is detected.
6823 *
6824 * Return value:
6825 * PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
6826 */
6827static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
6828 pci_channel_state_t state)
6829{
6830 switch (state) {
6831 case pci_channel_io_frozen:
6832 ipr_pci_frozen(pdev);
6833 return PCI_ERS_RESULT_NEED_RESET;
6834 case pci_channel_io_perm_failure:
6835 ipr_pci_perm_failure(pdev);
6836 return PCI_ERS_RESULT_DISCONNECT;
6837 break;
6838 default:
6839 break;
6840 }
6841 return PCI_ERS_RESULT_NEED_RESET;
6842}
6843
1da177e4
LT		 6844/**
6845 * ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
6846 * @ioa_cfg: ioa cfg struct
6847 *
6848 * Description: This is the second phase of adapter intialization
6849 * This function takes care of initilizing the adapter to the point
6850 * where it can accept new commands.
6851
6852 * Return value:
6853 * 0 on sucess / -EIO on failure
6854 **/
6855static int __devinit ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
6856{
6857 int rc = 0;
6858 unsigned long host_lock_flags = 0;
6859
6860 ENTER;
6861 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
6862 dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
ce155cce
BK		 6863 if (ioa_cfg->needs_hard_reset) {
6864 ioa_cfg->needs_hard_reset = 0;
6865 ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
6866 } else
6867 _ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
6868 IPR_SHUTDOWN_NONE);
1da177e4
LT		 6869
6870 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
6871 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
6872 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
6873
6874 if (ioa_cfg->ioa_is_dead) {
6875 rc = -EIO;
6876 } else if (ipr_invalid_adapter(ioa_cfg)) {
6877 if (!ipr_testmode)
6878 rc = -EIO;
6879
6880 dev_err(&ioa_cfg->pdev->dev,
6881 "Adapter not supported in this hardware configuration.\n");
6882 }
6883
6884 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
6885
6886 LEAVE;
6887 return rc;
6888}
6889
6890/**
6891 * ipr_free_cmd_blks - Frees command blocks allocated for an adapter
6892 * @ioa_cfg: ioa config struct
6893 *
6894 * Return value:
6895 * none
6896 **/
6897static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
6898{
6899 int i;
6900
6901 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
6902 if (ioa_cfg->ipr_cmnd_list[i])
6903 pci_pool_free(ioa_cfg->ipr_cmd_pool,
6904 ioa_cfg->ipr_cmnd_list[i],
6905 ioa_cfg->ipr_cmnd_list_dma[i]);
6906
6907 ioa_cfg->ipr_cmnd_list[i] = NULL;
6908 }
6909
6910 if (ioa_cfg->ipr_cmd_pool)
6911 pci_pool_destroy (ioa_cfg->ipr_cmd_pool);
6912
6913 ioa_cfg->ipr_cmd_pool = NULL;
6914}
6915
6916/**
6917 * ipr_free_mem - Frees memory allocated for an adapter
6918 * @ioa_cfg: ioa cfg struct
6919 *
6920 * Return value:
6921 * nothing
6922 **/
6923static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
6924{
6925 int i;
6926
6927 kfree(ioa_cfg->res_entries);
6928 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_misc_cbs),
6929 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
6930 ipr_free_cmd_blks(ioa_cfg);
6931 pci_free_consistent(ioa_cfg->pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
6932 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
6933 pci_free_consistent(ioa_cfg->pdev, sizeof(struct ipr_config_table),
6934 ioa_cfg->cfg_table,
6935 ioa_cfg->cfg_table_dma);
6936
6937 for (i = 0; i < IPR_NUM_HCAMS; i++) {
6938 pci_free_consistent(ioa_cfg->pdev,
6939 sizeof(struct ipr_hostrcb),
6940 ioa_cfg->hostrcb[i],
6941 ioa_cfg->hostrcb_dma[i]);
6942 }
6943
6944 ipr_free_dump(ioa_cfg);
1da177e4
LT		 6945 kfree(ioa_cfg->trace);
6946}
6947
6948/**
6949 * ipr_free_all_resources - Free all allocated resources for an adapter.
6950 * @ipr_cmd: ipr command struct
6951 *
6952 * This function frees all allocated resources for the
6953 * specified adapter.
6954 *
6955 * Return value:
6956 * none
6957 **/
6958static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
6959{
6960 struct pci_dev *pdev = ioa_cfg->pdev;
6961
6962 ENTER;
6963 free_irq(pdev->irq, ioa_cfg);
6964 iounmap(ioa_cfg->hdw_dma_regs);
6965 pci_release_regions(pdev);
6966 ipr_free_mem(ioa_cfg);
6967 scsi_host_put(ioa_cfg->host);
6968 pci_disable_device(pdev);
6969 LEAVE;
6970}
6971
6972/**
6973 * ipr_alloc_cmd_blks - Allocate command blocks for an adapter
6974 * @ioa_cfg: ioa config struct
6975 *
6976 * Return value:
6977 * 0 on success / -ENOMEM on allocation failure
6978 **/
6979static int __devinit ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
6980{
6981 struct ipr_cmnd *ipr_cmd;
6982 struct ipr_ioarcb *ioarcb;
6983 dma_addr_t dma_addr;
6984 int i;
6985
6986 ioa_cfg->ipr_cmd_pool = pci_pool_create (IPR_NAME, ioa_cfg->pdev,
6987 sizeof(struct ipr_cmnd), 8, 0);
6988
6989 if (!ioa_cfg->ipr_cmd_pool)
6990 return -ENOMEM;
6991
6992 for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
e94b1766 6993 ipr_cmd = pci_pool_alloc (ioa_cfg->ipr_cmd_pool, GFP_KERNEL, &dma_addr);
1da177e4
LT		 6994
6995 if (!ipr_cmd) {
6996 ipr_free_cmd_blks(ioa_cfg);
6997 return -ENOMEM;
6998 }
6999
7000 memset(ipr_cmd, 0, sizeof(*ipr_cmd));
7001 ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
7002 ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
7003
7004 ioarcb = &ipr_cmd->ioarcb;
7005 ioarcb->ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
7006 ioarcb->host_response_handle = cpu_to_be32(i << 2);
7007 ioarcb->write_ioadl_addr =
7008 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioadl));
7009 ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
7010 ioarcb->ioasa_host_pci_addr =
7011 cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, ioasa));
7012 ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
7013 ipr_cmd->cmd_index = i;
7014 ipr_cmd->ioa_cfg = ioa_cfg;
7015 ipr_cmd->sense_buffer_dma = dma_addr +
7016 offsetof(struct ipr_cmnd, sense_buffer);
7017
7018 list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
7019 }
7020
7021 return 0;
7022}
7023
7024/**
7025 * ipr_alloc_mem - Allocate memory for an adapter
7026 * @ioa_cfg: ioa config struct
7027 *
7028 * Return value:
7029 * 0 on success / non-zero for error
7030 **/
7031static int __devinit ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
7032{
7033 struct pci_dev *pdev = ioa_cfg->pdev;
7034 int i, rc = -ENOMEM;
7035
7036 ENTER;
0bc42e35 7037 ioa_cfg->res_entries = kzalloc(sizeof(struct ipr_resource_entry) *
1da177e4
LT		 7038 IPR_MAX_PHYSICAL_DEVS, GFP_KERNEL);
7039
7040 if (!ioa_cfg->res_entries)
7041 goto out;
7042
1da177e4
LT		 7043 for (i = 0; i < IPR_MAX_PHYSICAL_DEVS; i++)
7044 list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
7045
7046 ioa_cfg->vpd_cbs = pci_alloc_consistent(ioa_cfg->pdev,
7047 sizeof(struct ipr_misc_cbs),
7048 &ioa_cfg->vpd_cbs_dma);
7049
7050 if (!ioa_cfg->vpd_cbs)
7051 goto out_free_res_entries;
7052
7053 if (ipr_alloc_cmd_blks(ioa_cfg))
7054 goto out_free_vpd_cbs;
7055
7056 ioa_cfg->host_rrq = pci_alloc_consistent(ioa_cfg->pdev,
7057 sizeof(u32) * IPR_NUM_CMD_BLKS,
7058 &ioa_cfg->host_rrq_dma);
7059
7060 if (!ioa_cfg->host_rrq)
7061 goto out_ipr_free_cmd_blocks;
7062
7063 ioa_cfg->cfg_table = pci_alloc_consistent(ioa_cfg->pdev,
7064 sizeof(struct ipr_config_table),
7065 &ioa_cfg->cfg_table_dma);
7066
7067 if (!ioa_cfg->cfg_table)
7068 goto out_free_host_rrq;
7069
7070 for (i = 0; i < IPR_NUM_HCAMS; i++) {
7071 ioa_cfg->hostrcb[i] = pci_alloc_consistent(ioa_cfg->pdev,
7072 sizeof(struct ipr_hostrcb),
7073 &ioa_cfg->hostrcb_dma[i]);
7074
7075 if (!ioa_cfg->hostrcb[i])
7076 goto out_free_hostrcb_dma;
7077
7078 ioa_cfg->hostrcb[i]->hostrcb_dma =
7079 ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
49dc6a18 7080 ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
1da177e4
LT		 7081 list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
7082 }
7083
0bc42e35 7084 ioa_cfg->trace = kzalloc(sizeof(struct ipr_trace_entry) *
1da177e4
LT		 7085 IPR_NUM_TRACE_ENTRIES, GFP_KERNEL);
7086
7087 if (!ioa_cfg->trace)
7088 goto out_free_hostrcb_dma;
7089
1da177e4
LT		 7090 rc = 0;
7091out:
7092 LEAVE;
7093 return rc;
7094
7095out_free_hostrcb_dma:
7096 while (i-- > 0) {
7097 pci_free_consistent(pdev, sizeof(struct ipr_hostrcb),
7098 ioa_cfg->hostrcb[i],
7099 ioa_cfg->hostrcb_dma[i]);
7100 }
7101 pci_free_consistent(pdev, sizeof(struct ipr_config_table),
7102 ioa_cfg->cfg_table, ioa_cfg->cfg_table_dma);
7103out_free_host_rrq:
7104 pci_free_consistent(pdev, sizeof(u32) * IPR_NUM_CMD_BLKS,
7105 ioa_cfg->host_rrq, ioa_cfg->host_rrq_dma);
7106out_ipr_free_cmd_blocks:
7107 ipr_free_cmd_blks(ioa_cfg);
7108out_free_vpd_cbs:
7109 pci_free_consistent(pdev, sizeof(struct ipr_misc_cbs),
7110 ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
7111out_free_res_entries:
7112 kfree(ioa_cfg->res_entries);
7113 goto out;
7114}
7115
7116/**
7117 * ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
7118 * @ioa_cfg: ioa config struct
7119 *
7120 * Return value:
7121 * none
7122 **/
7123static void __devinit ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
7124{
7125 int i;
7126
7127 for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
7128 ioa_cfg->bus_attr[i].bus = i;
7129 ioa_cfg->bus_attr[i].qas_enabled = 0;
7130 ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
7131 if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
7132 ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
7133 else
7134 ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
7135 }
7136}
7137
7138/**
7139 * ipr_init_ioa_cfg - Initialize IOA config struct
7140 * @ioa_cfg: ioa config struct
7141 * @host: scsi host struct
7142 * @pdev: PCI dev struct
7143 *
7144 * Return value:
7145 * none
7146 **/
7147static void __devinit ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
7148 struct Scsi_Host *host, struct pci_dev *pdev)
7149{
7150 const struct ipr_interrupt_offsets *p;
7151 struct ipr_interrupts *t;
7152 void __iomem *base;
7153
7154 ioa_cfg->host = host;
7155 ioa_cfg->pdev = pdev;
7156 ioa_cfg->log_level = ipr_log_level;
3d1d0da6 7157 ioa_cfg->doorbell = IPR_DOORBELL;
1da177e4
LT		 7158 sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
7159 sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
7160 sprintf(ioa_cfg->ipr_free_label, IPR_FREEQ_LABEL);
7161 sprintf(ioa_cfg->ipr_pending_label, IPR_PENDQ_LABEL);
7162 sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
7163 sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
7164 sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
7165 sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
7166
7167 INIT_LIST_HEAD(&ioa_cfg->free_q);
7168 INIT_LIST_HEAD(&ioa_cfg->pending_q);
7169 INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
7170 INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
7171 INIT_LIST_HEAD(&ioa_cfg->free_res_q);
7172 INIT_LIST_HEAD(&ioa_cfg->used_res_q);
c4028958 7173 INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
1da177e4
LT		 7174 init_waitqueue_head(&ioa_cfg->reset_wait_q);
7175 ioa_cfg->sdt_state = INACTIVE;
62275040
BK		 7176 if (ipr_enable_cache)
7177 ioa_cfg->cache_state = CACHE_ENABLED;
7178 else
7179 ioa_cfg->cache_state = CACHE_DISABLED;
1da177e4
LT		 7180
7181 ipr_initialize_bus_attr(ioa_cfg);
7182
7183 host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
7184 host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
7185 host->max_channel = IPR_MAX_BUS_TO_SCAN;
7186 host->unique_id = host->host_no;
7187 host->max_cmd_len = IPR_MAX_CDB_LEN;
7188 pci_set_drvdata(pdev, ioa_cfg);
7189
7190 p = &ioa_cfg->chip_cfg->regs;
7191 t = &ioa_cfg->regs;
7192 base = ioa_cfg->hdw_dma_regs;
7193
7194 t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
7195 t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
7196 t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
7197 t->clr_interrupt_reg = base + p->clr_interrupt_reg;
7198 t->sense_interrupt_reg = base + p->sense_interrupt_reg;
7199 t->ioarrin_reg = base + p->ioarrin_reg;
7200 t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
7201 t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
7202 t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
7203}
7204
7205/**
7206 * ipr_get_chip_cfg - Find adapter chip configuration
7207 * @dev_id: PCI device id struct
7208 *
7209 * Return value:
7210 * ptr to chip config on success / NULL on failure
7211 **/
7212static const struct ipr_chip_cfg_t * __devinit
7213ipr_get_chip_cfg(const struct pci_device_id *dev_id)
7214{
7215 int i;
7216
1da177e4
LT		 7217 for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
7218 if (ipr_chip[i].vendor == dev_id->vendor &&
7219 ipr_chip[i].device == dev_id->device)
7220 return ipr_chip[i].cfg;
7221 return NULL;
7222}
7223
7224/**
7225 * ipr_probe_ioa - Allocates memory and does first stage of initialization
7226 * @pdev: PCI device struct
7227 * @dev_id: PCI device id struct
7228 *
7229 * Return value:
7230 * 0 on success / non-zero on failure
7231 **/
7232static int __devinit ipr_probe_ioa(struct pci_dev *pdev,
7233 const struct pci_device_id *dev_id)
7234{
7235 struct ipr_ioa_cfg *ioa_cfg;
7236 struct Scsi_Host *host;
7237 unsigned long ipr_regs_pci;
7238 void __iomem *ipr_regs;
a2a65a3e 7239 int rc = PCIBIOS_SUCCESSFUL;
ce155cce 7240 volatile u32 mask, uproc;
1da177e4
LT		 7241
7242 ENTER;
7243
7244 if ((rc = pci_enable_device(pdev))) {
7245 dev_err(&pdev->dev, "Cannot enable adapter\n");
7246 goto out;
7247 }
7248
7249 dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
7250
7251 host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
7252
7253 if (!host) {
7254 dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
7255 rc = -ENOMEM;
7256 goto out_disable;
7257 }
7258
7259 ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
7260 memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
35a39691
BK		 7261 ata_host_init(&ioa_cfg->ata_host, &pdev->dev,
7262 sata_port_info.flags, &ipr_sata_ops);
1da177e4
LT		 7263
7264 ioa_cfg->chip_cfg = ipr_get_chip_cfg(dev_id);
7265
7266 if (!ioa_cfg->chip_cfg) {
7267 dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
7268 dev_id->vendor, dev_id->device);
7269 goto out_scsi_host_put;
7270 }
7271
5469cb5b
BK		 7272 if (ipr_transop_timeout)
7273 ioa_cfg->transop_timeout = ipr_transop_timeout;
7274 else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
7275 ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
7276 else
7277 ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
7278
1da177e4
LT		 7279 ipr_regs_pci = pci_resource_start(pdev, 0);
7280
7281 rc = pci_request_regions(pdev, IPR_NAME);
7282 if (rc < 0) {
7283 dev_err(&pdev->dev,
7284 "Couldn't register memory range of registers\n");
7285 goto out_scsi_host_put;
7286 }
7287
7288 ipr_regs = ioremap(ipr_regs_pci, pci_resource_len(pdev, 0));
7289
7290 if (!ipr_regs) {
7291 dev_err(&pdev->dev,
7292 "Couldn't map memory range of registers\n");
7293 rc = -ENOMEM;
7294 goto out_release_regions;
7295 }
7296
7297 ioa_cfg->hdw_dma_regs = ipr_regs;
7298 ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
7299 ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
7300
7301 ipr_init_ioa_cfg(ioa_cfg, host, pdev);
7302
7303 pci_set_master(pdev);
7304
7305 rc = pci_set_dma_mask(pdev, DMA_32BIT_MASK);
7306 if (rc < 0) {
7307 dev_err(&pdev->dev, "Failed to set PCI DMA mask\n");
7308 goto cleanup_nomem;
7309 }
7310
7311 rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
7312 ioa_cfg->chip_cfg->cache_line_size);
7313
7314 if (rc != PCIBIOS_SUCCESSFUL) {
7315 dev_err(&pdev->dev, "Write of cache line size failed\n");
7316 rc = -EIO;
7317 goto cleanup_nomem;
7318 }
7319
7320 /* Save away PCI config space for use following IOA reset */
7321 rc = pci_save_state(pdev);
7322
7323 if (rc != PCIBIOS_SUCCESSFUL) {
7324 dev_err(&pdev->dev, "Failed to save PCI config space\n");
7325 rc = -EIO;
7326 goto cleanup_nomem;
7327 }
7328
7329 if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
7330 goto cleanup_nomem;
7331
7332 if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
7333 goto cleanup_nomem;
7334
7335 rc = ipr_alloc_mem(ioa_cfg);
7336 if (rc < 0) {
7337 dev_err(&pdev->dev,
7338 "Couldn't allocate enough memory for device driver!\n");
7339 goto cleanup_nomem;
7340 }
7341
ce155cce
BK		 7342 /*
7343 * If HRRQ updated interrupt is not masked, or reset alert is set,
7344 * the card is in an unknown state and needs a hard reset
7345 */
7346 mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
7347 uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg);
7348 if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
7349 ioa_cfg->needs_hard_reset = 1;
7350
1da177e4 7351 ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
1d6f359a 7352 rc = request_irq(pdev->irq, ipr_isr, IRQF_SHARED, IPR_NAME, ioa_cfg);
1da177e4
LT		 7353
7354 if (rc) {
7355 dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
7356 pdev->irq, rc);
7357 goto cleanup_nolog;
7358 }
7359
7360 spin_lock(&ipr_driver_lock);
7361 list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
7362 spin_unlock(&ipr_driver_lock);
7363
7364 LEAVE;
7365out:
7366 return rc;
7367
7368cleanup_nolog:
7369 ipr_free_mem(ioa_cfg);
7370cleanup_nomem:
7371 iounmap(ipr_regs);
7372out_release_regions:
7373 pci_release_regions(pdev);
7374out_scsi_host_put:
7375 scsi_host_put(host);
7376out_disable:
7377 pci_disable_device(pdev);
7378 goto out;
7379}
7380
7381/**
7382 * ipr_scan_vsets - Scans for VSET devices
7383 * @ioa_cfg: ioa config struct
7384 *
7385 * Description: Since the VSET resources do not follow SAM in that we can have
7386 * sparse LUNs with no LUN 0, we have to scan for these ourselves.
7387 *
7388 * Return value:
7389 * none
7390 **/
7391static void ipr_scan_vsets(struct ipr_ioa_cfg *ioa_cfg)
7392{
7393 int target, lun;
7394
7395 for (target = 0; target < IPR_MAX_NUM_TARGETS_PER_BUS; target++)
7396 for (lun = 0; lun < IPR_MAX_NUM_VSET_LUNS_PER_TARGET; lun++ )
7397 scsi_add_device(ioa_cfg->host, IPR_VSET_BUS, target, lun);
7398}
7399
7400/**
7401 * ipr_initiate_ioa_bringdown - Bring down an adapter
7402 * @ioa_cfg: ioa config struct
7403 * @shutdown_type: shutdown type
7404 *
7405 * Description: This function will initiate bringing down the adapter.
7406 * This consists of issuing an IOA shutdown to the adapter
7407 * to flush the cache, and running BIST.
7408 * If the caller needs to wait on the completion of the reset,
7409 * the caller must sleep on the reset_wait_q.
7410 *
7411 * Return value:
7412 * none
7413 **/
7414static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
7415 enum ipr_shutdown_type shutdown_type)
7416{
7417 ENTER;
7418 if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
7419 ioa_cfg->sdt_state = ABORT_DUMP;
7420 ioa_cfg->reset_retries = 0;
7421 ioa_cfg->in_ioa_bringdown = 1;
7422 ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
7423 LEAVE;
7424}
7425
7426/**
7427 * __ipr_remove - Remove a single adapter
7428 * @pdev: pci device struct
7429 *
7430 * Adapter hot plug remove entry point.
7431 *
7432 * Return value:
7433 * none
7434 **/
7435static void __ipr_remove(struct pci_dev *pdev)
7436{
7437 unsigned long host_lock_flags = 0;
7438 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
7439 ENTER;
7440
7441 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
970ea294
BK		 7442 while(ioa_cfg->in_reset_reload) {
7443 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
7444 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
7445 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
7446 }
7447
1da177e4
LT		 7448 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
7449
7450 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
7451 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
5cbf5eae 7452 flush_scheduled_work();
1da177e4
LT		 7453 spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
7454
7455 spin_lock(&ipr_driver_lock);
7456 list_del(&ioa_cfg->queue);
7457 spin_unlock(&ipr_driver_lock);
7458
7459 if (ioa_cfg->sdt_state == ABORT_DUMP)
7460 ioa_cfg->sdt_state = WAIT_FOR_DUMP;
7461 spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
7462
7463 ipr_free_all_resources(ioa_cfg);
7464
7465 LEAVE;
7466}
7467
7468/**
7469 * ipr_remove - IOA hot plug remove entry point
7470 * @pdev: pci device struct
7471 *
7472 * Adapter hot plug remove entry point.
7473 *
7474 * Return value:
7475 * none
7476 **/
7477static void ipr_remove(struct pci_dev *pdev)
7478{
7479 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
7480
7481 ENTER;
7482
1da177e4
LT		 7483 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
7484 &ipr_trace_attr);
7485 ipr_remove_dump_file(&ioa_cfg->host->shost_classdev.kobj,
7486 &ipr_dump_attr);
7487 scsi_remove_host(ioa_cfg->host);
7488
7489 __ipr_remove(pdev);
7490
7491 LEAVE;
7492}
7493
7494/**
7495 * ipr_probe - Adapter hot plug add entry point
7496 *
7497 * Return value:
7498 * 0 on success / non-zero on failure
7499 **/
7500static int __devinit ipr_probe(struct pci_dev *pdev,
7501 const struct pci_device_id *dev_id)
7502{
7503 struct ipr_ioa_cfg *ioa_cfg;
7504 int rc;
7505
7506 rc = ipr_probe_ioa(pdev, dev_id);
7507
7508 if (rc)
7509 return rc;
7510
7511 ioa_cfg = pci_get_drvdata(pdev);
7512 rc = ipr_probe_ioa_part2(ioa_cfg);
7513
7514 if (rc) {
7515 __ipr_remove(pdev);
7516 return rc;
7517 }
7518
7519 rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
7520
7521 if (rc) {
7522 __ipr_remove(pdev);
7523 return rc;
7524 }
7525
7526 rc = ipr_create_trace_file(&ioa_cfg->host->shost_classdev.kobj,
7527 &ipr_trace_attr);
7528
7529 if (rc) {
7530 scsi_remove_host(ioa_cfg->host);
7531 __ipr_remove(pdev);
7532 return rc;
7533 }
7534
7535 rc = ipr_create_dump_file(&ioa_cfg->host->shost_classdev.kobj,
7536 &ipr_dump_attr);
7537
7538 if (rc) {
7539 ipr_remove_trace_file(&ioa_cfg->host->shost_classdev.kobj,
7540 &ipr_trace_attr);
7541 scsi_remove_host(ioa_cfg->host);
7542 __ipr_remove(pdev);
7543 return rc;
7544 }
7545
7546 scsi_scan_host(ioa_cfg->host);
7547 ipr_scan_vsets(ioa_cfg);
7548 scsi_add_device(ioa_cfg->host, IPR_IOA_BUS, IPR_IOA_TARGET, IPR_IOA_LUN);
7549 ioa_cfg->allow_ml_add_del = 1;
11cd8f12 7550 ioa_cfg->host->max_channel = IPR_VSET_BUS;
1da177e4
LT		 7551 schedule_work(&ioa_cfg->work_q);
7552 return 0;
7553}
7554
7555/**
7556 * ipr_shutdown - Shutdown handler.
d18c3db5 7557 * @pdev: pci device struct
1da177e4
LT		 7558 *
7559 * This function is invoked upon system shutdown/reboot. It will issue
7560 * an adapter shutdown to the adapter to flush the write cache.
7561 *
7562 * Return value:
7563 * none
7564 **/
d18c3db5 7565static void ipr_shutdown(struct pci_dev *pdev)
1da177e4 7566{
d18c3db5 7567 struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
1da177e4
LT		 7568 unsigned long lock_flags = 0;
7569
7570 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
970ea294
BK		 7571 while(ioa_cfg->in_reset_reload) {
7572 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
7573 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
7574 spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
7575 }
7576
1da177e4
LT		 7577 ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
7578 spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
7579 wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
7580}
7581
7582static struct pci_device_id ipr_pci_table[] __devinitdata = {
7583 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6d84c944 7584 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
1da177e4 7585 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6d84c944 7586 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
1da177e4 7587 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6d84c944 7588 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
1da177e4 7589 { PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
6d84c944 7590 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
1da177e4 7591 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6d84c944 7592 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
1da177e4 7593 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6d84c944 7594 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
1da177e4 7595 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
6d84c944 7596 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
86f51436 7597 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
5469cb5b
BK		 7598 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
7599 IPR_USE_LONG_TRANSOP_TIMEOUT },
86f51436 7600 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
6d84c944 7601 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
86f51436 7602 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
6d84c944 7603 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 0 },
60e7486b 7604 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
5469cb5b
BK		 7605 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
7606 IPR_USE_LONG_TRANSOP_TIMEOUT },
86f51436 7607 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
6d84c944 7608 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
86f51436 7609 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
6d84c944 7610 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0, 0 },
60e7486b 7611 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
5469cb5b
BK		 7612 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
7613 IPR_USE_LONG_TRANSOP_TIMEOUT },
185eb31c
BK		 7614 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
7615 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0, 0 },
7616 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
7617 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575D, 0, 0,
7618 IPR_USE_LONG_TRANSOP_TIMEOUT },
7619 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
7620 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
60e7486b 7621 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
5469cb5b
BK		 7622 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
7623 IPR_USE_LONG_TRANSOP_TIMEOUT },
1da177e4 7624 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
6d84c944 7625 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
1da177e4 7626 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
6d84c944 7627 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
86f51436 7628 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
5469cb5b
BK		 7629 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
7630 IPR_USE_LONG_TRANSOP_TIMEOUT },
60e7486b 7631 { PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
5469cb5b
BK		 7632 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
7633 IPR_USE_LONG_TRANSOP_TIMEOUT },
185eb31c
BK		 7634 { PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SCAMP_E,
7635 PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0,
7636 IPR_USE_LONG_TRANSOP_TIMEOUT },
1da177e4
LT		 7637 { }
7638};
7639MODULE_DEVICE_TABLE(pci, ipr_pci_table);
7640
f8a88b19
LV		 7641static struct pci_error_handlers ipr_err_handler = {
7642 .error_detected = ipr_pci_error_detected,
7643 .slot_reset = ipr_pci_slot_reset,
7644};
7645
1da177e4
LT		 7646static struct pci_driver ipr_driver = {
7647 .name = IPR_NAME,
7648 .id_table = ipr_pci_table,
7649 .probe = ipr_probe,
7650 .remove = ipr_remove,
d18c3db5 7651 .shutdown = ipr_shutdown,
f8a88b19 7652 .err_handler = &ipr_err_handler,
68c96e59 7653 .dynids.use_driver_data = 1
1da177e4
LT		 7654};
7655
7656/**
7657 * ipr_init - Module entry point
7658 *
7659 * Return value:
7660 * 0 on success / negative value on failure
7661 **/
7662static int __init ipr_init(void)
7663{
7664 ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
7665 IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
7666
dcbccbde 7667 return pci_register_driver(&ipr_driver);
1da177e4
LT		 7668}
7669
7670/**
7671 * ipr_exit - Module unload
7672 *
7673 * Module unload entry point.
7674 *
7675 * Return value:
7676 * none
7677 **/
7678static void __exit ipr_exit(void)
7679{
7680 pci_unregister_driver(&ipr_driver);
7681}
7682
7683module_init(ipr_init);
7684module_exit(ipr_exit);
ubuntu-zesty-kernel mirror