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