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