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