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