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