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