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