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