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