PageRenderTime 302ms CodeModel.GetById 60ms app.highlight 200ms RepoModel.GetById 1ms app.codeStats 1ms

/drivers/scsi/ipr.c

https://bitbucket.org/cyanogenmod/android_kernel_asus_tf300t
C | 9237 lines | 5898 code | 1206 blank | 2133 comment | 861 complexity | a3660cded51ae2342d2ce8c903ee1110 MD5 | raw file
Possible License(s): LGPL-2.0, AGPL-1.0, GPL-2.0
   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
  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>
  62#include <linux/slab.h>
  63#include <linux/vmalloc.h>
  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>
  75#include <linux/libata.h>
  76#include <linux/hdreg.h>
  77#include <linux/reboot.h>
  78#include <linux/stringify.h>
  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>
  87#include "ipr.h"
  88
  89/*
  90 *   Global Data
  91 */
  92static LIST_HEAD(ipr_ioa_head);
  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;
  97static unsigned int ipr_transop_timeout = 0;
  98static unsigned int ipr_debug = 0;
  99static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
 100static unsigned int ipr_dual_ioa_raid = 1;
 101static DEFINE_SPINLOCK(ipr_driver_lock);
 102
 103/* This table describes the differences between DMA controller chips */
 104static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
 105	{ /* Gemstone, Citrine, Obsidian, and Obsidian-E */
 106		.mailbox = 0x0042C,
 107		.cache_line_size = 0x20,
 108		{
 109			.set_interrupt_mask_reg = 0x0022C,
 110			.clr_interrupt_mask_reg = 0x00230,
 111			.clr_interrupt_mask_reg32 = 0x00230,
 112			.sense_interrupt_mask_reg = 0x0022C,
 113			.sense_interrupt_mask_reg32 = 0x0022C,
 114			.clr_interrupt_reg = 0x00228,
 115			.clr_interrupt_reg32 = 0x00228,
 116			.sense_interrupt_reg = 0x00224,
 117			.sense_interrupt_reg32 = 0x00224,
 118			.ioarrin_reg = 0x00404,
 119			.sense_uproc_interrupt_reg = 0x00214,
 120			.sense_uproc_interrupt_reg32 = 0x00214,
 121			.set_uproc_interrupt_reg = 0x00214,
 122			.set_uproc_interrupt_reg32 = 0x00214,
 123			.clr_uproc_interrupt_reg = 0x00218,
 124			.clr_uproc_interrupt_reg32 = 0x00218
 125		}
 126	},
 127	{ /* Snipe and Scamp */
 128		.mailbox = 0x0052C,
 129		.cache_line_size = 0x20,
 130		{
 131			.set_interrupt_mask_reg = 0x00288,
 132			.clr_interrupt_mask_reg = 0x0028C,
 133			.clr_interrupt_mask_reg32 = 0x0028C,
 134			.sense_interrupt_mask_reg = 0x00288,
 135			.sense_interrupt_mask_reg32 = 0x00288,
 136			.clr_interrupt_reg = 0x00284,
 137			.clr_interrupt_reg32 = 0x00284,
 138			.sense_interrupt_reg = 0x00280,
 139			.sense_interrupt_reg32 = 0x00280,
 140			.ioarrin_reg = 0x00504,
 141			.sense_uproc_interrupt_reg = 0x00290,
 142			.sense_uproc_interrupt_reg32 = 0x00290,
 143			.set_uproc_interrupt_reg = 0x00290,
 144			.set_uproc_interrupt_reg32 = 0x00290,
 145			.clr_uproc_interrupt_reg = 0x00294,
 146			.clr_uproc_interrupt_reg32 = 0x00294
 147		}
 148	},
 149	{ /* CRoC */
 150		.mailbox = 0x00044,
 151		.cache_line_size = 0x20,
 152		{
 153			.set_interrupt_mask_reg = 0x00010,
 154			.clr_interrupt_mask_reg = 0x00018,
 155			.clr_interrupt_mask_reg32 = 0x0001C,
 156			.sense_interrupt_mask_reg = 0x00010,
 157			.sense_interrupt_mask_reg32 = 0x00014,
 158			.clr_interrupt_reg = 0x00008,
 159			.clr_interrupt_reg32 = 0x0000C,
 160			.sense_interrupt_reg = 0x00000,
 161			.sense_interrupt_reg32 = 0x00004,
 162			.ioarrin_reg = 0x00070,
 163			.sense_uproc_interrupt_reg = 0x00020,
 164			.sense_uproc_interrupt_reg32 = 0x00024,
 165			.set_uproc_interrupt_reg = 0x00020,
 166			.set_uproc_interrupt_reg32 = 0x00024,
 167			.clr_uproc_interrupt_reg = 0x00028,
 168			.clr_uproc_interrupt_reg32 = 0x0002C,
 169			.init_feedback_reg = 0x0005C,
 170			.dump_addr_reg = 0x00064,
 171			.dump_data_reg = 0x00068,
 172			.endian_swap_reg = 0x00084
 173		}
 174	},
 175};
 176
 177static const struct ipr_chip_t ipr_chip[] = {
 178	{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 179	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 180	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 181	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 182	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, IPR_USE_MSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
 183	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
 184	{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, IPR_USE_LSI, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
 185	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
 186	{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_ASIC_E2, IPR_USE_MSI, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
 187};
 188
 189static int ipr_max_bus_speeds [] = {
 190	IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
 191};
 192
 193MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
 194MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
 195module_param_named(max_speed, ipr_max_speed, uint, 0);
 196MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
 197module_param_named(log_level, ipr_log_level, uint, 0);
 198MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
 199module_param_named(testmode, ipr_testmode, int, 0);
 200MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
 201module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
 202MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
 203module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
 204MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
 205module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
 206MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
 207module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
 208MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
 209module_param_named(max_devs, ipr_max_devs, int, 0);
 210MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
 211		 "[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
 212MODULE_LICENSE("GPL");
 213MODULE_VERSION(IPR_DRIVER_VERSION);
 214
 215/*  A constant array of IOASCs/URCs/Error Messages */
 216static const
 217struct ipr_error_table_t ipr_error_table[] = {
 218	{0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
 219	"8155: An unknown error was received"},
 220	{0x00330000, 0, 0,
 221	"Soft underlength error"},
 222	{0x005A0000, 0, 0,
 223	"Command to be cancelled not found"},
 224	{0x00808000, 0, 0,
 225	"Qualified success"},
 226	{0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
 227	"FFFE: Soft device bus error recovered by the IOA"},
 228	{0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
 229	"4101: Soft device bus fabric error"},
 230	{0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
 231	"FFFC: Logical block guard error recovered by the device"},
 232	{0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
 233	"FFFC: Logical block reference tag error recovered by the device"},
 234	{0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
 235	"4171: Recovered scatter list tag / sequence number error"},
 236	{0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
 237	"FF3D: Recovered logical block CRC error on IOA to Host transfer"},
 238	{0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
 239	"4171: Recovered logical block sequence number error on IOA to Host transfer"},
 240	{0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
 241	"FFFD: Recovered logical block reference tag error detected by the IOA"},
 242	{0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
 243	"FFFD: Logical block guard error recovered by the IOA"},
 244	{0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
 245	"FFF9: Device sector reassign successful"},
 246	{0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
 247	"FFF7: Media error recovered by device rewrite procedures"},
 248	{0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
 249	"7001: IOA sector reassignment successful"},
 250	{0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
 251	"FFF9: Soft media error. Sector reassignment recommended"},
 252	{0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
 253	"FFF7: Media error recovered by IOA rewrite procedures"},
 254	{0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
 255	"FF3D: Soft PCI bus error recovered by the IOA"},
 256	{0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
 257	"FFF6: Device hardware error recovered by the IOA"},
 258	{0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
 259	"FFF6: Device hardware error recovered by the device"},
 260	{0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
 261	"FF3D: Soft IOA error recovered by the IOA"},
 262	{0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
 263	"FFFA: Undefined device response recovered by the IOA"},
 264	{0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
 265	"FFF6: Device bus error, message or command phase"},
 266	{0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
 267	"FFFE: Task Management Function failed"},
 268	{0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
 269	"FFF6: Failure prediction threshold exceeded"},
 270	{0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
 271	"8009: Impending cache battery pack failure"},
 272	{0x02040400, 0, 0,
 273	"34FF: Disk device format in progress"},
 274	{0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
 275	"9070: IOA requested reset"},
 276	{0x023F0000, 0, 0,
 277	"Synchronization required"},
 278	{0x024E0000, 0, 0,
 279	"No ready, IOA shutdown"},
 280	{0x025A0000, 0, 0,
 281	"Not ready, IOA has been shutdown"},
 282	{0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
 283	"3020: Storage subsystem configuration error"},
 284	{0x03110B00, 0, 0,
 285	"FFF5: Medium error, data unreadable, recommend reassign"},
 286	{0x03110C00, 0, 0,
 287	"7000: Medium error, data unreadable, do not reassign"},
 288	{0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
 289	"FFF3: Disk media format bad"},
 290	{0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
 291	"3002: Addressed device failed to respond to selection"},
 292	{0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
 293	"3100: Device bus error"},
 294	{0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
 295	"3109: IOA timed out a device command"},
 296	{0x04088000, 0, 0,
 297	"3120: SCSI bus is not operational"},
 298	{0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
 299	"4100: Hard device bus fabric error"},
 300	{0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
 301	"310C: Logical block guard error detected by the device"},
 302	{0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
 303	"310C: Logical block reference tag error detected by the device"},
 304	{0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
 305	"4170: Scatter list tag / sequence number error"},
 306	{0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
 307	"8150: Logical block CRC error on IOA to Host transfer"},
 308	{0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
 309	"4170: Logical block sequence number error on IOA to Host transfer"},
 310	{0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
 311	"310D: Logical block reference tag error detected by the IOA"},
 312	{0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
 313	"310D: Logical block guard error detected by the IOA"},
 314	{0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
 315	"9000: IOA reserved area data check"},
 316	{0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
 317	"9001: IOA reserved area invalid data pattern"},
 318	{0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
 319	"9002: IOA reserved area LRC error"},
 320	{0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
 321	"Hardware Error, IOA metadata access error"},
 322	{0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
 323	"102E: Out of alternate sectors for disk storage"},
 324	{0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
 325	"FFF4: Data transfer underlength error"},
 326	{0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
 327	"FFF4: Data transfer overlength error"},
 328	{0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
 329	"3400: Logical unit failure"},
 330	{0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
 331	"FFF4: Device microcode is corrupt"},
 332	{0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
 333	"8150: PCI bus error"},
 334	{0x04430000, 1, 0,
 335	"Unsupported device bus message received"},
 336	{0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
 337	"FFF4: Disk device problem"},
 338	{0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
 339	"8150: Permanent IOA failure"},
 340	{0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
 341	"3010: Disk device returned wrong response to IOA"},
 342	{0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
 343	"8151: IOA microcode error"},
 344	{0x04448500, 0, 0,
 345	"Device bus status error"},
 346	{0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
 347	"8157: IOA error requiring IOA reset to recover"},
 348	{0x04448700, 0, 0,
 349	"ATA device status error"},
 350	{0x04490000, 0, 0,
 351	"Message reject received from the device"},
 352	{0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
 353	"8008: A permanent cache battery pack failure occurred"},
 354	{0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
 355	"9090: Disk unit has been modified after the last known status"},
 356	{0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
 357	"9081: IOA detected device error"},
 358	{0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
 359	"9082: IOA detected device error"},
 360	{0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
 361	"3110: Device bus error, message or command phase"},
 362	{0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
 363	"3110: SAS Command / Task Management Function failed"},
 364	{0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
 365	"9091: Incorrect hardware configuration change has been detected"},
 366	{0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
 367	"9073: Invalid multi-adapter configuration"},
 368	{0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
 369	"4010: Incorrect connection between cascaded expanders"},
 370	{0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
 371	"4020: Connections exceed IOA design limits"},
 372	{0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
 373	"4030: Incorrect multipath connection"},
 374	{0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
 375	"4110: Unsupported enclosure function"},
 376	{0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
 377	"FFF4: Command to logical unit failed"},
 378	{0x05240000, 1, 0,
 379	"Illegal request, invalid request type or request packet"},
 380	{0x05250000, 0, 0,
 381	"Illegal request, invalid resource handle"},
 382	{0x05258000, 0, 0,
 383	"Illegal request, commands not allowed to this device"},
 384	{0x05258100, 0, 0,
 385	"Illegal request, command not allowed to a secondary adapter"},
 386	{0x05258200, 0, 0,
 387	"Illegal request, command not allowed to a non-optimized resource"},
 388	{0x05260000, 0, 0,
 389	"Illegal request, invalid field in parameter list"},
 390	{0x05260100, 0, 0,
 391	"Illegal request, parameter not supported"},
 392	{0x05260200, 0, 0,
 393	"Illegal request, parameter value invalid"},
 394	{0x052C0000, 0, 0,
 395	"Illegal request, command sequence error"},
 396	{0x052C8000, 1, 0,
 397	"Illegal request, dual adapter support not enabled"},
 398	{0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
 399	"9031: Array protection temporarily suspended, protection resuming"},
 400	{0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
 401	"9040: Array protection temporarily suspended, protection resuming"},
 402	{0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
 403	"3140: Device bus not ready to ready transition"},
 404	{0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
 405	"FFFB: SCSI bus was reset"},
 406	{0x06290500, 0, 0,
 407	"FFFE: SCSI bus transition to single ended"},
 408	{0x06290600, 0, 0,
 409	"FFFE: SCSI bus transition to LVD"},
 410	{0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
 411	"FFFB: SCSI bus was reset by another initiator"},
 412	{0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
 413	"3029: A device replacement has occurred"},
 414	{0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
 415	"9051: IOA cache data exists for a missing or failed device"},
 416	{0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
 417	"9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
 418	{0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
 419	"9025: Disk unit is not supported at its physical location"},
 420	{0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
 421	"3020: IOA detected a SCSI bus configuration error"},
 422	{0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
 423	"3150: SCSI bus configuration error"},
 424	{0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
 425	"9074: Asymmetric advanced function disk configuration"},
 426	{0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
 427	"4040: Incomplete multipath connection between IOA and enclosure"},
 428	{0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
 429	"4041: Incomplete multipath connection between enclosure and device"},
 430	{0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
 431	"9075: Incomplete multipath connection between IOA and remote IOA"},
 432	{0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
 433	"9076: Configuration error, missing remote IOA"},
 434	{0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
 435	"4050: Enclosure does not support a required multipath function"},
 436	{0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
 437	"4070: Logically bad block written on device"},
 438	{0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
 439	"9041: Array protection temporarily suspended"},
 440	{0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
 441	"9042: Corrupt array parity detected on specified device"},
 442	{0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
 443	"9030: Array no longer protected due to missing or failed disk unit"},
 444	{0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
 445	"9071: Link operational transition"},
 446	{0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
 447	"9072: Link not operational transition"},
 448	{0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
 449	"9032: Array exposed but still protected"},
 450	{0x066B8300, 0, IPR_DEFAULT_LOG_LEVEL + 1,
 451	"70DD: Device forced failed by disrupt device command"},
 452	{0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
 453	"4061: Multipath redundancy level got better"},
 454	{0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
 455	"4060: Multipath redundancy level got worse"},
 456	{0x07270000, 0, 0,
 457	"Failure due to other device"},
 458	{0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
 459	"9008: IOA does not support functions expected by devices"},
 460	{0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
 461	"9010: Cache data associated with attached devices cannot be found"},
 462	{0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
 463	"9011: Cache data belongs to devices other than those attached"},
 464	{0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
 465	"9020: Array missing 2 or more devices with only 1 device present"},
 466	{0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
 467	"9021: Array missing 2 or more devices with 2 or more devices present"},
 468	{0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
 469	"9022: Exposed array is missing a required device"},
 470	{0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
 471	"9023: Array member(s) not at required physical locations"},
 472	{0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
 473	"9024: Array not functional due to present hardware configuration"},
 474	{0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
 475	"9026: Array not functional due to present hardware configuration"},
 476	{0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
 477	"9027: Array is missing a device and parity is out of sync"},
 478	{0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
 479	"9028: Maximum number of arrays already exist"},
 480	{0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
 481	"9050: Required cache data cannot be located for a disk unit"},
 482	{0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
 483	"9052: Cache data exists for a device that has been modified"},
 484	{0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
 485	"9054: IOA resources not available due to previous problems"},
 486	{0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
 487	"9092: Disk unit requires initialization before use"},
 488	{0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
 489	"9029: Incorrect hardware configuration change has been detected"},
 490	{0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
 491	"9060: One or more disk pairs are missing from an array"},
 492	{0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
 493	"9061: One or more disks are missing from an array"},
 494	{0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
 495	"9062: One or more disks are missing from an array"},
 496	{0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
 497	"9063: Maximum number of functional arrays has been exceeded"},
 498	{0x0B260000, 0, 0,
 499	"Aborted command, invalid descriptor"},
 500	{0x0B5A0000, 0, 0,
 501	"Command terminated by host"}
 502};
 503
 504static const struct ipr_ses_table_entry ipr_ses_table[] = {
 505	{ "2104-DL1        ", "XXXXXXXXXXXXXXXX", 80 },
 506	{ "2104-TL1        ", "XXXXXXXXXXXXXXXX", 80 },
 507	{ "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
 508	{ "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
 509	{ "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
 510	{ "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
 511	{ "2104-DU3        ", "XXXXXXXXXXXXXXXX", 160 },
 512	{ "2104-TU3        ", "XXXXXXXXXXXXXXXX", 160 },
 513	{ "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
 514	{ "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
 515	{ "St  V1S2        ", "XXXXXXXXXXXXXXXX", 160 },
 516	{ "HSBPD4M  PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
 517	{ "VSBPD1H   U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
 518};
 519
 520/*
 521 *  Function Prototypes
 522 */
 523static int ipr_reset_alert(struct ipr_cmnd *);
 524static void ipr_process_ccn(struct ipr_cmnd *);
 525static void ipr_process_error(struct ipr_cmnd *);
 526static void ipr_reset_ioa_job(struct ipr_cmnd *);
 527static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
 528				   enum ipr_shutdown_type);
 529
 530#ifdef CONFIG_SCSI_IPR_TRACE
 531/**
 532 * ipr_trc_hook - Add a trace entry to the driver trace
 533 * @ipr_cmd:	ipr command struct
 534 * @type:		trace type
 535 * @add_data:	additional data
 536 *
 537 * Return value:
 538 * 	none
 539 **/
 540static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
 541			 u8 type, u32 add_data)
 542{
 543	struct ipr_trace_entry *trace_entry;
 544	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 545
 546	trace_entry = &ioa_cfg->trace[ioa_cfg->trace_index++];
 547	trace_entry->time = jiffies;
 548	trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
 549	trace_entry->type = type;
 550	if (ipr_cmd->ioa_cfg->sis64)
 551		trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
 552	else
 553		trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
 554	trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
 555	trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
 556	trace_entry->u.add_data = add_data;
 557}
 558#else
 559#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while(0)
 560#endif
 561
 562/**
 563 * ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
 564 * @ipr_cmd:	ipr command struct
 565 *
 566 * Return value:
 567 * 	none
 568 **/
 569static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
 570{
 571	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
 572	struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
 573	struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
 574	dma_addr_t dma_addr = ipr_cmd->dma_addr;
 575
 576	memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
 577	ioarcb->data_transfer_length = 0;
 578	ioarcb->read_data_transfer_length = 0;
 579	ioarcb->ioadl_len = 0;
 580	ioarcb->read_ioadl_len = 0;
 581
 582	if (ipr_cmd->ioa_cfg->sis64) {
 583		ioarcb->u.sis64_addr_data.data_ioadl_addr =
 584			cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
 585		ioasa64->u.gata.status = 0;
 586	} else {
 587		ioarcb->write_ioadl_addr =
 588			cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
 589		ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
 590		ioasa->u.gata.status = 0;
 591	}
 592
 593	ioasa->hdr.ioasc = 0;
 594	ioasa->hdr.residual_data_len = 0;
 595	ipr_cmd->scsi_cmd = NULL;
 596	ipr_cmd->qc = NULL;
 597	ipr_cmd->sense_buffer[0] = 0;
 598	ipr_cmd->dma_use_sg = 0;
 599}
 600
 601/**
 602 * ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
 603 * @ipr_cmd:	ipr command struct
 604 *
 605 * Return value:
 606 * 	none
 607 **/
 608static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
 609{
 610	ipr_reinit_ipr_cmnd(ipr_cmd);
 611	ipr_cmd->u.scratch = 0;
 612	ipr_cmd->sibling = NULL;
 613	init_timer(&ipr_cmd->timer);
 614}
 615
 616/**
 617 * ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
 618 * @ioa_cfg:	ioa config struct
 619 *
 620 * Return value:
 621 * 	pointer to ipr command struct
 622 **/
 623static
 624struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
 625{
 626	struct ipr_cmnd *ipr_cmd;
 627
 628	ipr_cmd = list_entry(ioa_cfg->free_q.next, struct ipr_cmnd, queue);
 629	list_del(&ipr_cmd->queue);
 630	ipr_init_ipr_cmnd(ipr_cmd);
 631
 632	return ipr_cmd;
 633}
 634
 635/**
 636 * ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
 637 * @ioa_cfg:	ioa config struct
 638 * @clr_ints:     interrupts to clear
 639 *
 640 * This function masks all interrupts on the adapter, then clears the
 641 * interrupts specified in the mask
 642 *
 643 * Return value:
 644 * 	none
 645 **/
 646static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
 647					  u32 clr_ints)
 648{
 649	volatile u32 int_reg;
 650
 651	/* Stop new interrupts */
 652	ioa_cfg->allow_interrupts = 0;
 653
 654	/* Set interrupt mask to stop all new interrupts */
 655	if (ioa_cfg->sis64)
 656		writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
 657	else
 658		writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
 659
 660	/* Clear any pending interrupts */
 661	if (ioa_cfg->sis64)
 662		writel(~0, ioa_cfg->regs.clr_interrupt_reg);
 663	writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
 664	int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
 665}
 666
 667/**
 668 * ipr_save_pcix_cmd_reg - Save PCI-X command register
 669 * @ioa_cfg:	ioa config struct
 670 *
 671 * Return value:
 672 * 	0 on success / -EIO on failure
 673 **/
 674static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
 675{
 676	int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
 677
 678	if (pcix_cmd_reg == 0)
 679		return 0;
 680
 681	if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
 682				 &ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
 683		dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
 684		return -EIO;
 685	}
 686
 687	ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
 688	return 0;
 689}
 690
 691/**
 692 * ipr_set_pcix_cmd_reg - Setup PCI-X command register
 693 * @ioa_cfg:	ioa config struct
 694 *
 695 * Return value:
 696 * 	0 on success / -EIO on failure
 697 **/
 698static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
 699{
 700	int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
 701
 702	if (pcix_cmd_reg) {
 703		if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
 704					  ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
 705			dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
 706			return -EIO;
 707		}
 708	}
 709
 710	return 0;
 711}
 712
 713/**
 714 * ipr_sata_eh_done - done function for aborted SATA commands
 715 * @ipr_cmd:	ipr command struct
 716 *
 717 * This function is invoked for ops generated to SATA
 718 * devices which are being aborted.
 719 *
 720 * Return value:
 721 * 	none
 722 **/
 723static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
 724{
 725	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 726	struct ata_queued_cmd *qc = ipr_cmd->qc;
 727	struct ipr_sata_port *sata_port = qc->ap->private_data;
 728
 729	qc->err_mask |= AC_ERR_OTHER;
 730	sata_port->ioasa.status |= ATA_BUSY;
 731	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 732	ata_qc_complete(qc);
 733}
 734
 735/**
 736 * ipr_scsi_eh_done - mid-layer done function for aborted ops
 737 * @ipr_cmd:	ipr command struct
 738 *
 739 * This function is invoked by the interrupt handler for
 740 * ops generated by the SCSI mid-layer which are being aborted.
 741 *
 742 * Return value:
 743 * 	none
 744 **/
 745static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
 746{
 747	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 748	struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
 749
 750	scsi_cmd->result |= (DID_ERROR << 16);
 751
 752	scsi_dma_unmap(ipr_cmd->scsi_cmd);
 753	scsi_cmd->scsi_done(scsi_cmd);
 754	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
 755}
 756
 757/**
 758 * ipr_fail_all_ops - Fails all outstanding ops.
 759 * @ioa_cfg:	ioa config struct
 760 *
 761 * This function fails all outstanding ops.
 762 *
 763 * Return value:
 764 * 	none
 765 **/
 766static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
 767{
 768	struct ipr_cmnd *ipr_cmd, *temp;
 769
 770	ENTER;
 771	list_for_each_entry_safe(ipr_cmd, temp, &ioa_cfg->pending_q, queue) {
 772		list_del(&ipr_cmd->queue);
 773
 774		ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
 775		ipr_cmd->s.ioasa.hdr.ilid = cpu_to_be32(IPR_DRIVER_ILID);
 776
 777		if (ipr_cmd->scsi_cmd)
 778			ipr_cmd->done = ipr_scsi_eh_done;
 779		else if (ipr_cmd->qc)
 780			ipr_cmd->done = ipr_sata_eh_done;
 781
 782		ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, IPR_IOASC_IOA_WAS_RESET);
 783		del_timer(&ipr_cmd->timer);
 784		ipr_cmd->done(ipr_cmd);
 785	}
 786
 787	LEAVE;
 788}
 789
 790/**
 791 * ipr_send_command -  Send driver initiated requests.
 792 * @ipr_cmd:		ipr command struct
 793 *
 794 * This function sends a command to the adapter using the correct write call.
 795 * In the case of sis64, calculate the ioarcb size required. Then or in the
 796 * appropriate bits.
 797 *
 798 * Return value:
 799 * 	none
 800 **/
 801static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
 802{
 803	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 804	dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
 805
 806	if (ioa_cfg->sis64) {
 807		/* The default size is 256 bytes */
 808		send_dma_addr |= 0x1;
 809
 810		/* If the number of ioadls * size of ioadl > 128 bytes,
 811		   then use a 512 byte ioarcb */
 812		if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
 813			send_dma_addr |= 0x4;
 814		writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
 815	} else
 816		writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
 817}
 818
 819/**
 820 * ipr_do_req -  Send driver initiated requests.
 821 * @ipr_cmd:		ipr command struct
 822 * @done:			done function
 823 * @timeout_func:	timeout function
 824 * @timeout:		timeout value
 825 *
 826 * This function sends the specified command to the adapter with the
 827 * timeout given. The done function is invoked on command completion.
 828 *
 829 * Return value:
 830 * 	none
 831 **/
 832static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
 833		       void (*done) (struct ipr_cmnd *),
 834		       void (*timeout_func) (struct ipr_cmnd *), u32 timeout)
 835{
 836	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 837
 838	list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
 839
 840	ipr_cmd->done = done;
 841
 842	ipr_cmd->timer.data = (unsigned long) ipr_cmd;
 843	ipr_cmd->timer.expires = jiffies + timeout;
 844	ipr_cmd->timer.function = (void (*)(unsigned long))timeout_func;
 845
 846	add_timer(&ipr_cmd->timer);
 847
 848	ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
 849
 850	mb();
 851
 852	ipr_send_command(ipr_cmd);
 853}
 854
 855/**
 856 * ipr_internal_cmd_done - Op done function for an internally generated op.
 857 * @ipr_cmd:	ipr command struct
 858 *
 859 * This function is the op done function for an internally generated,
 860 * blocking op. It simply wakes the sleeping thread.
 861 *
 862 * Return value:
 863 * 	none
 864 **/
 865static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
 866{
 867	if (ipr_cmd->sibling)
 868		ipr_cmd->sibling = NULL;
 869	else
 870		complete(&ipr_cmd->completion);
 871}
 872
 873/**
 874 * ipr_init_ioadl - initialize the ioadl for the correct SIS type
 875 * @ipr_cmd:	ipr command struct
 876 * @dma_addr:	dma address
 877 * @len:	transfer length
 878 * @flags:	ioadl flag value
 879 *
 880 * This function initializes an ioadl in the case where there is only a single
 881 * descriptor.
 882 *
 883 * Return value:
 884 * 	nothing
 885 **/
 886static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
 887			   u32 len, int flags)
 888{
 889	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
 890	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
 891
 892	ipr_cmd->dma_use_sg = 1;
 893
 894	if (ipr_cmd->ioa_cfg->sis64) {
 895		ioadl64->flags = cpu_to_be32(flags);
 896		ioadl64->data_len = cpu_to_be32(len);
 897		ioadl64->address = cpu_to_be64(dma_addr);
 898
 899		ipr_cmd->ioarcb.ioadl_len =
 900		       	cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
 901		ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
 902	} else {
 903		ioadl->flags_and_data_len = cpu_to_be32(flags | len);
 904		ioadl->address = cpu_to_be32(dma_addr);
 905
 906		if (flags == IPR_IOADL_FLAGS_READ_LAST) {
 907			ipr_cmd->ioarcb.read_ioadl_len =
 908				cpu_to_be32(sizeof(struct ipr_ioadl_desc));
 909			ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
 910		} else {
 911			ipr_cmd->ioarcb.ioadl_len =
 912			       	cpu_to_be32(sizeof(struct ipr_ioadl_desc));
 913			ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
 914		}
 915	}
 916}
 917
 918/**
 919 * ipr_send_blocking_cmd - Send command and sleep on its completion.
 920 * @ipr_cmd:	ipr command struct
 921 * @timeout_func:	function to invoke if command times out
 922 * @timeout:	timeout
 923 *
 924 * Return value:
 925 * 	none
 926 **/
 927static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
 928				  void (*timeout_func) (struct ipr_cmnd *ipr_cmd),
 929				  u32 timeout)
 930{
 931	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
 932
 933	init_completion(&ipr_cmd->completion);
 934	ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
 935
 936	spin_unlock_irq(ioa_cfg->host->host_lock);
 937	wait_for_completion(&ipr_cmd->completion);
 938	spin_lock_irq(ioa_cfg->host->host_lock);
 939}
 940
 941/**
 942 * ipr_send_hcam - Send an HCAM to the adapter.
 943 * @ioa_cfg:	ioa config struct
 944 * @type:		HCAM type
 945 * @hostrcb:	hostrcb struct
 946 *
 947 * This function will send a Host Controlled Async command to the adapter.
 948 * If HCAMs are currently not allowed to be issued to the adapter, it will
 949 * place the hostrcb on the free queue.
 950 *
 951 * Return value:
 952 * 	none
 953 **/
 954static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
 955			  struct ipr_hostrcb *hostrcb)
 956{
 957	struct ipr_cmnd *ipr_cmd;
 958	struct ipr_ioarcb *ioarcb;
 959
 960	if (ioa_cfg->allow_cmds) {
 961		ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
 962		list_add_tail(&ipr_cmd->queue, &ioa_cfg->pending_q);
 963		list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
 964
 965		ipr_cmd->u.hostrcb = hostrcb;
 966		ioarcb = &ipr_cmd->ioarcb;
 967
 968		ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
 969		ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
 970		ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
 971		ioarcb->cmd_pkt.cdb[1] = type;
 972		ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
 973		ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
 974
 975		ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
 976			       sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
 977
 978		if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
 979			ipr_cmd->done = ipr_process_ccn;
 980		else
 981			ipr_cmd->done = ipr_process_error;
 982
 983		ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
 984
 985		mb();
 986
 987		ipr_send_command(ipr_cmd);
 988	} else {
 989		list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
 990	}
 991}
 992
 993/**
 994 * ipr_update_ata_class - Update the ata class in the resource entry
 995 * @res:	resource entry struct
 996 * @proto:	cfgte device bus protocol value
 997 *
 998 * Return value:
 999 * 	none
1000 **/
1001static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
1002{
1003	switch(proto) {
1004	case IPR_PROTO_SATA:
1005	case IPR_PROTO_SAS_STP:
1006		res->ata_class = ATA_DEV_ATA;
1007		break;
1008	case IPR_PROTO_SATA_ATAPI:
1009	case IPR_PROTO_SAS_STP_ATAPI:
1010		res->ata_class = ATA_DEV_ATAPI;
1011		break;
1012	default:
1013		res->ata_class = ATA_DEV_UNKNOWN;
1014		break;
1015	};
1016}
1017
1018/**
1019 * ipr_init_res_entry - Initialize a resource entry struct.
1020 * @res:	resource entry struct
1021 * @cfgtew:	config table entry wrapper struct
1022 *
1023 * Return value:
1024 * 	none
1025 **/
1026static void ipr_init_res_entry(struct ipr_resource_entry *res,
1027			       struct ipr_config_table_entry_wrapper *cfgtew)
1028{
1029	int found = 0;
1030	unsigned int proto;
1031	struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1032	struct ipr_resource_entry *gscsi_res = NULL;
1033
1034	res->needs_sync_complete = 0;
1035	res->in_erp = 0;
1036	res->add_to_ml = 0;
1037	res->del_from_ml = 0;
1038	res->resetting_device = 0;
1039	res->sdev = NULL;
1040	res->sata_port = NULL;
1041
1042	if (ioa_cfg->sis64) {
1043		proto = cfgtew->u.cfgte64->proto;
1044		res->res_flags = cfgtew->u.cfgte64->res_flags;
1045		res->qmodel = IPR_QUEUEING_MODEL64(res);
1046		res->type = cfgtew->u.cfgte64->res_type;
1047
1048		memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1049			sizeof(res->res_path));
1050
1051		res->bus = 0;
1052		memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1053			sizeof(res->dev_lun.scsi_lun));
1054		res->lun = scsilun_to_int(&res->dev_lun);
1055
1056		if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1057			list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
1058				if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
1059					found = 1;
1060					res->target = gscsi_res->target;
1061					break;
1062				}
1063			}
1064			if (!found) {
1065				res->target = find_first_zero_bit(ioa_cfg->target_ids,
1066								  ioa_cfg->max_devs_supported);
1067				set_bit(res->target, ioa_cfg->target_ids);
1068			}
1069		} else if (res->type == IPR_RES_TYPE_IOAFP) {
1070			res->bus = IPR_IOAFP_VIRTUAL_BUS;
1071			res->target = 0;
1072		} else if (res->type == IPR_RES_TYPE_ARRAY) {
1073			res->bus = IPR_ARRAY_VIRTUAL_BUS;
1074			res->target = find_first_zero_bit(ioa_cfg->array_ids,
1075							  ioa_cfg->max_devs_supported);
1076			set_bit(res->target, ioa_cfg->array_ids);
1077		} else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
1078			res->bus = IPR_VSET_VIRTUAL_BUS;
1079			res->target = find_first_zero_bit(ioa_cfg->vset_ids,
1080							  ioa_cfg->max_devs_supported);
1081			set_bit(res->target, ioa_cfg->vset_ids);
1082		} else {
1083			res->target = find_first_zero_bit(ioa_cfg->target_ids,
1084							  ioa_cfg->max_devs_supported);
1085			set_bit(res->target, ioa_cfg->target_ids);
1086		}
1087	} else {
1088		proto = cfgtew->u.cfgte->proto;
1089		res->qmodel = IPR_QUEUEING_MODEL(res);
1090		res->flags = cfgtew->u.cfgte->flags;
1091		if (res->flags & IPR_IS_IOA_RESOURCE)
1092			res->type = IPR_RES_TYPE_IOAFP;
1093		else
1094			res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1095
1096		res->bus = cfgtew->u.cfgte->res_addr.bus;
1097		res->target = cfgtew->u.cfgte->res_addr.target;
1098		res->lun = cfgtew->u.cfgte->res_addr.lun;
1099		res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
1100	}
1101
1102	ipr_update_ata_class(res, proto);
1103}
1104
1105/**
1106 * ipr_is_same_device - Determine if two devices are the same.
1107 * @res:	resource entry struct
1108 * @cfgtew:	config table entry wrapper struct
1109 *
1110 * Return value:
1111 * 	1 if the devices are the same / 0 otherwise
1112 **/
1113static int ipr_is_same_device(struct ipr_resource_entry *res,
1114			      struct ipr_config_table_entry_wrapper *cfgtew)
1115{
1116	if (res->ioa_cfg->sis64) {
1117		if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
1118					sizeof(cfgtew->u.cfgte64->dev_id)) &&
1119			!memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1120					sizeof(cfgtew->u.cfgte64->lun))) {
1121			return 1;
1122		}
1123	} else {
1124		if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
1125		    res->target == cfgtew->u.cfgte->res_addr.target &&
1126		    res->lun == cfgtew->u.cfgte->res_addr.lun)
1127			return 1;
1128	}
1129
1130	return 0;
1131}
1132
1133/**
1134 * ipr_format_res_path - Format the resource path for printing.
1135 * @res_path:	resource path
1136 * @buf:	buffer
1137 *
1138 * Return value:
1139 * 	pointer to buffer
1140 **/
1141static char *ipr_format_res_path(u8 *res_path, char *buffer, int len)
1142{
1143	int i;
1144	char *p = buffer;
1145
1146	*p = '\0';
1147	p += snprintf(p, buffer + len - p, "%02X", res_path[0]);
1148	for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++)
1149		p += snprintf(p, buffer + len - p, "-%02X", res_path[i]);
1150
1151	return buffer;
1152}
1153
1154/**
1155 * ipr_update_res_entry - Update the resource entry.
1156 * @res:	resource entry struct
1157 * @cfgtew:	config table entry wrapper struct
1158 *
1159 * Return value:
1160 *      none
1161 **/
1162static void ipr_update_res_entry(struct ipr_resource_entry *res,
1163				 struct ipr_config_table_entry_wrapper *cfgtew)
1164{
1165	char buffer[IPR_MAX_RES_PATH_LENGTH];
1166	unsigned int proto;
1167	int new_path = 0;
1168
1169	if (res->ioa_cfg->sis64) {
1170		res->flags = cfgtew->u.cfgte64->flags;
1171		res->res_flags = cfgtew->u.cfgte64->res_flags;
1172		res->type = cfgtew->u.cfgte64->res_type;
1173
1174		memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
1175			sizeof(struct ipr_std_inq_data));
1176
1177		res->qmodel = IPR_QUEUEING_MODEL64(res);
1178		proto = cfgtew->u.cfgte64->proto;
1179		res->res_handle = cfgtew->u.cfgte64->res_handle;
1180		res->dev_id = cfgtew->u.cfgte64->dev_id;
1181
1182		memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
1183			sizeof(res->dev_lun.scsi_lun));
1184
1185		if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
1186					sizeof(res->res_path))) {
1187			memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
1188				sizeof(res->res_path));
1189			new_path = 1;
1190		}
1191
1192		if (res->sdev && new_path)
1193			sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
1194				    ipr_format_res_path(res->res_path, buffer,
1195							sizeof(buffer)));
1196	} else {
1197		res->flags = cfgtew->u.cfgte->flags;
1198		if (res->flags & IPR_IS_IOA_RESOURCE)
1199			res->type = IPR_RES_TYPE_IOAFP;
1200		else
1201			res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
1202
1203		memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
1204			sizeof(struct ipr_std_inq_data));
1205
1206		res->qmodel = IPR_QUEUEING_MODEL(res);
1207		proto = cfgtew->u.cfgte->proto;
1208		res->res_handle = cfgtew->u.cfgte->res_handle;
1209	}
1210
1211	ipr_update_ata_class(res, proto);
1212}
1213
1214/**
1215 * ipr_clear_res_target - Clear the bit in the bit map representing the target
1216 * 			  for the resource.
1217 * @res:	resource entry struct
1218 * @cfgtew:	config table entry wrapper struct
1219 *
1220 * Return value:
1221 *      none
1222 **/
1223static void ipr_clear_res_target(struct ipr_resource_entry *res)
1224{
1225	struct ipr_resource_entry *gscsi_res = NULL;
1226	struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
1227
1228	if (!ioa_cfg->sis64)
1229		return;
1230
1231	if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
1232		clear_bit(res->target, ioa_cfg->array_ids);
1233	else if (res->bus == IPR_VSET_VIRTUAL_BUS)
1234		clear_bit(res->target, ioa_cfg->vset_ids);
1235	else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
1236		list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
1237			if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
1238				return;
1239		clear_bit(res->target, ioa_cfg->target_ids);
1240
1241	} else if (res->bus == 0)
1242		clear_bit(res->target, ioa_cfg->target_ids);
1243}
1244
1245/**
1246 * ipr_handle_config_change - Handle a config change from the adapter
1247 * @ioa_cfg:	ioa config struct
1248 * @hostrcb:	hostrcb
1249 *
1250 * Return value:
1251 * 	none
1252 **/
1253static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
1254				     struct ipr_hostrcb *hostrcb)
1255{
1256	struct ipr_resource_entry *res = NULL;
1257	struct ipr_config_table_entry_wrapper cfgtew;
1258	__be32 cc_res_handle;
1259
1260	u32 is_ndn = 1;
1261
1262	if (ioa_cfg->sis64) {
1263		cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
1264		cc_res_handle = cfgtew.u.cfgte64->res_handle;
1265	} else {
1266		cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
1267		cc_res_handle = cfgtew.u.cfgte->res_handle;
1268	}
1269
1270	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
1271		if (res->res_handle == cc_res_handle) {
1272			is_ndn = 0;
1273			break;
1274		}
1275	}
1276
1277	if (is_ndn) {
1278		if (list_empty(&ioa_cfg->free_res_q)) {
1279			ipr_send_hcam(ioa_cfg,
1280				      IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
1281				      hostrcb);
1282			return;
1283		}
1284
1285		res = list_entry(ioa_cfg->free_res_q.next,
1286				 struct ipr_resource_entry, queue);
1287
1288		list_del(&res->queue);
1289		ipr_init_res_entry(res, &cfgtew);
1290		list_add_tail(&res->queue, &ioa_cfg->used_res_q);
1291	}
1292
1293	ipr_update_res_entry(res, &cfgtew);
1294
1295	if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
1296		if (res->sdev) {
1297			res->del_from_ml = 1;
1298			res->res_handle = IPR_INVALID_RES_HANDLE;
1299			if (ioa_cfg->allow_ml_add_del)
1300				schedule_work(&ioa_cfg->work_q);
1301		} else {
1302			ipr_clear_res_target(res);
1303			list_move_tail(&res->queue, &ioa_cfg->free_res_q);
1304		}
1305	} else if (!res->sdev || res->del_from_ml) {
1306		res->add_to_ml = 1;
1307		if (ioa_cfg->allow_ml_add_del)
1308			schedule_work(&ioa_cfg->work_q);
1309	}
1310
1311	ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1312}
1313
1314/**
1315 * ipr_process_ccn - Op done function for a CCN.
1316 * @ipr_cmd:	ipr command struct
1317 *
1318 * This function is the op done function for a configuration
1319 * change notification host controlled async from the adapter.
1320 *
1321 * Return value:
1322 * 	none
1323 **/
1324static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
1325{
1326	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
1327	struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
1328	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
1329
1330	list_del(&hostrcb->queue);
1331	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
1332
1333	if (ioasc) {
1334		if (ioasc != IPR_IOASC_IOA_WAS_RESET)
1335			dev_err(&ioa_cfg->pdev->dev,
1336				"Host RCB failed with IOASC: 0x%08X\n", ioasc);
1337
1338		ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
1339	} else {
1340		ipr_handle_config_change(ioa_cfg, hostrcb);
1341	}
1342}
1343
1344/**
1345 * strip_and_pad_whitespace - Strip and pad trailing whitespace.
1346 * @i:		index into buffer
1347 * @buf:		string to modify
1348 *
1349 * This function will strip all trailing whitespace, pad the end
1350 * of the string with a single space, and NULL terminate the string.
1351 *
1352 * Return value:
1353 * 	new length of string
1354 **/
1355static int strip_and_pad_whitespace(int i, char *buf)
1356{
1357	while (i && buf[i] == ' ')
1358		i--;
1359	buf[i+1] = ' ';
1360	buf[i+2] = '\0';
1361	return i + 2;
1362}
1363
1364/**
1365 * ipr_log_vpd_compact - Log the passed extended VPD compactly.
1366 * @prefix:		string to print at start of printk
1367 * @hostrcb:	hostrcb pointer
1368 * @vpd:		vendor/product id/sn struct
1369 *
1370 * Return value:
1371 * 	none
1372 **/
1373static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1374				struct ipr_vpd *vpd)
1375{
1376	char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
1377	int i = 0;
1378
1379	memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1380	i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
1381
1382	memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
1383	i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
1384
1385	memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
1386	buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
1387
1388	ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
1389}
1390
1391/**
1392 * ipr_log_vpd - Log the passed VPD to the error log.
1393 * @vpd:		vendor/product id/sn struct
1394 *
1395 * Return value:
1396 * 	none
1397 **/
1398static void ipr_log_vpd(struct ipr_vpd *vpd)
1399{
1400	char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
1401		    + IPR_SERIAL_NUM_LEN];
1402
1403	memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
1404	memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
1405	       IPR_PROD_ID_LEN);
1406	buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
1407	ipr_err("Vendor/Product ID: %s\n", buffer);
1408
1409	memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
1410	buffer[IPR_SERIAL_NUM_LEN] = '\0';
1411	ipr_err("    Serial Number: %s\n", buffer);
1412}
1413
1414/**
1415 * ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
1416 * @prefix:		string to print at start of printk
1417 * @hostrcb:	hostrcb pointer
1418 * @vpd:		vendor/product id/sn/wwn struct
1419 *
1420 * Return value:
1421 * 	none
1422 **/
1423static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
1424				    struct ipr_ext_vpd *vpd)
1425{
1426	ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
1427	ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
1428		     be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
1429}
1430
1431/**
1432 * ipr_log_ext_vpd - Log the passed extended VPD to the error log.
1433 * @vpd:		vendor/product id/sn/wwn struct
1434 *
1435 * Return value:
1436 * 	none
1437 **/
1438static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
1439{
1440	ipr_log_vpd(&vpd->vpd);
1441	ipr_err("    WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
1442		be32_to_cpu(vpd->wwid[1]));
1443}
1444
1445/**
1446 * ipr_log_enhanced_cache_error - Log a cache error.
1447 * @ioa_cfg:	ioa config struct
1448 * @hostrcb:	hostrcb struct
1449 *
1450 * Return value:
1451 * 	none
1452 **/
1453static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1454					 struct ipr_hostrcb *hostrcb)
1455{
1456	struct ipr_hostrcb_type_12_error *error;
1457
1458	if (ioa_cfg->sis64)
1459		error = &hostrcb->hcam.u.error64.u.type_12_error;
1460	else
1461		error = &hostrcb->hcam.u.error.u.type_12_error;
1462
1463	ipr_err("-----Current Configuration-----\n");
1464	ipr_err("Cache Directory Card Information:\n");
1465	ipr_log_ext_vpd(&error->ioa_vpd);
1466	ipr_err("Adapter Card Information:\n");
1467	ipr_log_ext_vpd(&error->cfc_vpd);
1468
1469	ipr_err("-----Expected Configuration-----\n");
1470	ipr_err("Cache Directory Card Information:\n");
1471	ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
1472	ipr_err("Adapter Card Information:\n");
1473	ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
1474
1475	ipr_err("Additional IOA Data: %08X %08X %08X\n",
1476		     be32_to_cpu(error->ioa_data[0]),
1477		     be32_to_cpu(error->ioa_data[1]),
1478		     be32_to_cpu(error->ioa_data[2]));
1479}
1480
1481/**
1482 * ipr_log_cache_error - Log a cache error.
1483 * @ioa_cfg:	ioa config struct
1484 * @hostrcb:	hostrcb struct
1485 *
1486 * Return value:
1487 * 	none
1488 **/
1489static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
1490				struct ipr_hostrcb *hostrcb)
1491{
1492	struct ipr_hostrcb_type_02_error *error =
1493		&hostrcb->hcam.u.error.u.type_02_error;
1494
1495	ipr_err("-----Current Configuration-----\n");
1496	ipr_err("Cache Directory Card Information:\n");
1497	ipr_log_vpd(&error->ioa_vpd);
1498	ipr_err("Adapter Card Information:\n");
1499	ipr_log_vpd(&error->cfc_vpd);
1500
1501	ipr_err("-----Expected Configuration-----\n");
1502	ipr_err("Cache Directory Card Information:\n");
1503	ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
1504	ipr_err("Adapter Card Information:\n");
1505	ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
1506
1507	ipr_err("Additional IOA Data: %08X %08X %08X\n",
1508		     be32_to_cpu(error->ioa_data[0]),
1509		     be32_to_cpu(error->ioa_data[1]),
1510		     be32_to_cpu(error->ioa_data[2]));
1511}
1512
1513/**
1514 * ipr_log_enhanced_config_error - Log a configuration error.
1515 * @ioa_cfg:	ioa config struct
1516 * @hostrcb:	hostrcb struct
1517 *
1518 * Return value:
1519 * 	none
1520 **/
1521static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
1522					  struct ipr_hostrcb *hostrcb)
1523{
1524	int errors_logged, i;
1525	struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
1526	struct ipr_hostrcb_type_13_error *error;
1527
1528	error = &hostrcb->hcam.u.error.u.type_13_error;
1529	errors_logged = be32_to_cpu(error->errors_logged);
1530
1531	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1532		be32_to_cpu(error->errors_detected), errors_logged);
1533
1534	dev_entry = error->dev;
1535
1536	for (i = 0; i < errors_logged; i++, dev_entry++) {
1537		ipr_err_separator;
1538
1539		ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1540		ipr_log_ext_vpd(&dev_entry->vpd);
1541
1542		ipr_err("-----New Device Information-----\n");
1543		ipr_log_ext_vpd(&dev_entry->new_vpd);
1544
1545		ipr_err("Cache Directory Card Information:\n");
1546		ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1547
1548		ipr_err("Adapter Card Information:\n");
1549		ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1550	}
1551}
1552
1553/**
1554 * ipr_log_sis64_config_error - Log a device error.
1555 * @ioa_cfg:	ioa config struct
1556 * @hostrcb:	hostrcb struct
1557 *
1558 * Return value:
1559 * 	none
1560 **/
1561static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
1562				       struct ipr_hostrcb *hostrcb)
1563{
1564	int errors_logged, i;
1565	struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
1566	struct ipr_hostrcb_type_23_error *error;
1567	char buffer[IPR_MAX_RES_PATH_LENGTH];
1568
1569	error = &hostrcb->hcam.u.error64.u.type_23_error;
1570	errors_logged = be32_to_cpu(error->errors_logged);
1571
1572	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1573		be32_to_cpu(error->errors_detected), errors_logged);
1574
1575	dev_entry = error->dev;
1576
1577	for (i = 0; i < errors_logged; i++, dev_entry++) {
1578		ipr_err_separator;
1579
1580		ipr_err("Device %d : %s", i + 1,
1581			 ipr_format_res_path(dev_entry->res_path, buffer,
1582					     sizeof(buffer)));
1583		ipr_log_ext_vpd(&dev_entry->vpd);
1584
1585		ipr_err("-----New Device Information-----\n");
1586		ipr_log_ext_vpd(&dev_entry->new_vpd);
1587
1588		ipr_err("Cache Directory Card Information:\n");
1589		ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
1590
1591		ipr_err("Adapter Card Information:\n");
1592		ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
1593	}
1594}
1595
1596/**
1597 * ipr_log_config_error - Log a configuration error.
1598 * @ioa_cfg:	ioa config struct
1599 * @hostrcb:	hostrcb struct
1600 *
1601 * Return value:
1602 * 	none
1603 **/
1604static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
1605				 struct ipr_hostrcb *hostrcb)
1606{
1607	int errors_logged, i;
1608	struct ipr_hostrcb_device_data_entry *dev_entry;
1609	struct ipr_hostrcb_type_03_error *error;
1610
1611	error = &hostrcb->hcam.u.error.u.type_03_error;
1612	errors_logged = be32_to_cpu(error->errors_logged);
1613
1614	ipr_err("Device Errors Detected/Logged: %d/%d\n",
1615		be32_to_cpu(error->errors_detected), errors_logged);
1616
1617	dev_entry = error->dev;
1618
1619	for (i = 0; i < errors_logged; i++, dev_entry++) {
1620		ipr_err_separator;
1621
1622		ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
1623		ipr_log_vpd(&dev_entry->vpd);
1624
1625		ipr_err("-----New Device Information-----\n");
1626		ipr_log_vpd(&dev_entry->new_vpd);
1627
1628		ipr_err("Cache Directory Card Information:\n");
1629		ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
1630
1631		ipr_err("Adapter Card Information:\n");
1632		ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
1633
1634		ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
1635			be32_to_cpu(dev_entry->ioa_data[0]),
1636			be32_to_cpu(dev_entry->ioa_data[1]),
1637			be32_to_cpu(dev_entry->ioa_data[2]),
1638			be32_to_cpu(dev_entry->ioa_data[3]),
1639			be32_to_cpu(dev_entry->ioa_data[4]));
1640	}
1641}
1642
1643/**
1644 * ipr_log_enhanced_array_error - Log an array configuration error.
1645 * @ioa_cfg:	ioa config struct
1646 * @hostrcb:	hostrcb struct
1647 *
1648 * Return value:
1649 * 	none
1650 **/
1651static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
1652					 struct ipr_hostrcb *hostrcb)
1653{
1654	int i, num_entries;
1655	struct ipr_hostrcb_type_14_error *error;
1656	struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
1657	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1658
1659	error = &hostrcb->hcam.u.error.u.type_14_error;
1660
1661	ipr_err_separator;
1662
1663	ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1664		error->protection_level,
1665		ioa_cfg->host->host_no,
1666		error->last_func_vset_res_addr.bus,
1667		error->last_func_vset_res_addr.target,
1668		error->last_func_vset_res_addr.lun);
1669
1670	ipr_err_separator;
1671
1672	array_entry = error->array_member;
1673	num_entries = min_t(u32, be32_to_cpu(error->num_entries),
1674			    ARRAY_SIZE(error->array_member));
1675
1676	for (i = 0; i < num_entries; i++, array_entry++) {
1677		if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1678			continue;
1679
1680		if (be32_to_cpu(error->exposed_mode_adn) == i)
1681			ipr_err("Exposed Array Member %d:\n", i);
1682		else
1683			ipr_err("Array Member %d:\n", i);
1684
1685		ipr_log_ext_vpd(&array_entry->vpd);
1686		ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1687		ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1688				 "Expected Location");
1689
1690		ipr_err_separator;
1691	}
1692}
1693
1694/**
1695 * ipr_log_array_error - Log an array configuration error.
1696 * @ioa_cfg:	ioa config struct
1697 * @hostrcb:	hostrcb struct
1698 *
1699 * Return value:
1700 * 	none
1701 **/
1702static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
1703				struct ipr_hostrcb *hostrcb)
1704{
1705	int i;
1706	struct ipr_hostrcb_type_04_error *error;
1707	struct ipr_hostrcb_array_data_entry *array_entry;
1708	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
1709
1710	error = &hostrcb->hcam.u.error.u.type_04_error;
1711
1712	ipr_err_separator;
1713
1714	ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
1715		error->protection_level,
1716		ioa_cfg->host->host_no,
1717		error->last_func_vset_res_addr.bus,
1718		error->last_func_vset_res_addr.target,
1719		error->last_func_vset_res_addr.lun);
1720
1721	ipr_err_separator;
1722
1723	array_entry = error->array_member;
1724
1725	for (i = 0; i < 18; i++) {
1726		if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
1727			continue;
1728
1729		if (be32_to_cpu(error->exposed_mode_adn) == i)
1730			ipr_err("Exposed Array Member %d:\n", i);
1731		else
1732			ipr_err("Array Member %d:\n", i);
1733
1734		ipr_log_vpd(&array_entry->vpd);
1735
1736		ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
1737		ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
1738				 "Expected Location");
1739
1740		ipr_err_separator;
1741
1742		if (i == 9)
1743			array_entry = error->array_member2;
1744		else
1745			array_entry++;
1746	}
1747}
1748
1749/**
1750 * ipr_log_hex_data - Log additional hex IOA error data.
1751 * @ioa_cfg:	ioa config struct
1752 * @data:		IOA error data
1753 * @len:		data length
1754 *
1755 * Return value:
1756 * 	none
1757 **/
1758static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, u32 *data, int len)
1759{
1760	int i;
1761
1762	if (len == 0)
1763		return;
1764
1765	if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
1766		len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
1767
1768	for (i = 0; i < len / 4; i += 4) {
1769		ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
1770			be32_to_cpu(data[i]),
1771			be32_to_cpu(data[i+1]),
1772			be32_to_cpu(data[i+2]),
1773			be32_to_cpu(data[i+3]));
1774	}
1775}
1776
1777/**
1778 * ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
1779 * @ioa_cfg:	ioa config struct
1780 * @hostrcb:	hostrcb struct
1781 *
1782 * Return value:
1783 * 	none
1784 **/
1785static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1786					    struct ipr_hostrcb *hostrcb)
1787{
1788	struct ipr_hostrcb_type_17_error *error;
1789
1790	if (ioa_cfg->sis64)
1791		error = &hostrcb->hcam.u.error64.u.type_17_error;
1792	else
1793		error = &hostrcb->hcam.u.error.u.type_17_error;
1794
1795	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1796	strim(error->failure_reason);
1797
1798	ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1799		     be32_to_cpu(hostrcb->hcam.u.error.prc));
1800	ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1801	ipr_log_hex_data(ioa_cfg, error->data,
1802			 be32_to_cpu(hostrcb->hcam.length) -
1803			 (offsetof(struct ipr_hostrcb_error, u) +
1804			  offsetof(struct ipr_hostrcb_type_17_error, data)));
1805}
1806
1807/**
1808 * ipr_log_dual_ioa_error - Log a dual adapter error.
1809 * @ioa_cfg:	ioa config struct
1810 * @hostrcb:	hostrcb struct
1811 *
1812 * Return value:
1813 * 	none
1814 **/
1815static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
1816				   struct ipr_hostrcb *hostrcb)
1817{
1818	struct ipr_hostrcb_type_07_error *error;
1819
1820	error = &hostrcb->hcam.u.error.u.type_07_error;
1821	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
1822	strim(error->failure_reason);
1823
1824	ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
1825		     be32_to_cpu(hostrcb->hcam.u.error.prc));
1826	ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
1827	ipr_log_hex_data(ioa_cfg, error->data,
1828			 be32_to_cpu(hostrcb->hcam.length) -
1829			 (offsetof(struct ipr_hostrcb_error, u) +
1830			  offsetof(struct ipr_hostrcb_type_07_error, data)));
1831}
1832
1833static const struct {
1834	u8 active;
1835	char *desc;
1836} path_active_desc[] = {
1837	{ IPR_PATH_NO_INFO, "Path" },
1838	{ IPR_PATH_ACTIVE, "Active path" },
1839	{ IPR_PATH_NOT_ACTIVE, "Inactive path" }
1840};
1841
1842static const struct {
1843	u8 state;
1844	char *desc;
1845} path_state_desc[] = {
1846	{ IPR_PATH_STATE_NO_INFO, "has no path state information available" },
1847	{ IPR_PATH_HEALTHY, "is healthy" },
1848	{ IPR_PATH_DEGRADED, "is degraded" },
1849	{ IPR_PATH_FAILED, "is failed" }
1850};
1851
1852/**
1853 * ipr_log_fabric_path - Log a fabric path error
1854 * @hostrcb:	hostrcb struct
1855 * @fabric:		fabric descriptor
1856 *
1857 * Return value:
1858 * 	none
1859 **/
1860static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
1861				struct ipr_hostrcb_fabric_desc *fabric)
1862{
1863	int i, j;
1864	u8 path_state = fabric->path_state;
1865	u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1866	u8 state = path_state & IPR_PATH_STATE_MASK;
1867
1868	for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1869		if (path_active_desc[i].active != active)
1870			continue;
1871
1872		for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1873			if (path_state_desc[j].state != state)
1874				continue;
1875
1876			if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
1877				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
1878					     path_active_desc[i].desc, path_state_desc[j].desc,
1879					     fabric->ioa_port);
1880			} else if (fabric->cascaded_expander == 0xff) {
1881				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
1882					     path_active_desc[i].desc, path_state_desc[j].desc,
1883					     fabric->ioa_port, fabric->phy);
1884			} else if (fabric->phy == 0xff) {
1885				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
1886					     path_active_desc[i].desc, path_state_desc[j].desc,
1887					     fabric->ioa_port, fabric->cascaded_expander);
1888			} else {
1889				ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
1890					     path_active_desc[i].desc, path_state_desc[j].desc,
1891					     fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1892			}
1893			return;
1894		}
1895	}
1896
1897	ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
1898		fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
1899}
1900
1901/**
1902 * ipr_log64_fabric_path - Log a fabric path error
1903 * @hostrcb:	hostrcb struct
1904 * @fabric:		fabric descriptor
1905 *
1906 * Return value:
1907 * 	none
1908 **/
1909static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
1910				  struct ipr_hostrcb64_fabric_desc *fabric)
1911{
1912	int i, j;
1913	u8 path_state = fabric->path_state;
1914	u8 active = path_state & IPR_PATH_ACTIVE_MASK;
1915	u8 state = path_state & IPR_PATH_STATE_MASK;
1916	char buffer[IPR_MAX_RES_PATH_LENGTH];
1917
1918	for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
1919		if (path_active_desc[i].active != active)
1920			continue;
1921
1922		for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
1923			if (path_state_desc[j].state != state)
1924				continue;
1925
1926			ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
1927				     path_active_desc[i].desc, path_state_desc[j].desc,
1928				     ipr_format_res_path(fabric->res_path, buffer,
1929							 sizeof(buffer)));
1930			return;
1931		}
1932	}
1933
1934	ipr_err("Path state=%02X Resource Path=%s\n", path_state,
1935		ipr_format_res_path(fabric->res_path, buffer, sizeof(buffer)));
1936}
1937
1938static const struct {
1939	u8 type;
1940	char *desc;
1941} path_type_desc[] = {
1942	{ IPR_PATH_CFG_IOA_PORT, "IOA port" },
1943	{ IPR_PATH_CFG_EXP_PORT, "Expander port" },
1944	{ IPR_PATH_CFG_DEVICE_PORT, "Device port" },
1945	{ IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
1946};
1947
1948static const struct {
1949	u8 status;
1950	char *desc;
1951} path_status_desc[] = {
1952	{ IPR_PATH_CFG_NO_PROB, "Functional" },
1953	{ IPR_PATH_CFG_DEGRADED, "Degraded" },
1954	{ IPR_PATH_CFG_FAILED, "Failed" },
1955	{ IPR_PATH_CFG_SUSPECT, "Suspect" },
1956	{ IPR_PATH_NOT_DETECTED, "Missing" },
1957	{ IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
1958};
1959
1960static const char *link_rate[] = {
1961	"unknown",
1962	"disabled",
1963	"phy reset problem",
1964	"spinup hold",
1965	"port selector",
1966	"unknown",
1967	"unknown",
1968	"unknown",
1969	"1.5Gbps",
1970	"3.0Gbps",
1971	"unknown",
1972	"unknown",
1973	"unknown",
1974	"unknown",
1975	"unknown",
1976	"unknown"
1977};
1978
1979/**
1980 * ipr_log_path_elem - Log a fabric path element.
1981 * @hostrcb:	hostrcb struct
1982 * @cfg:		fabric path element struct
1983 *
1984 * Return value:
1985 * 	none
1986 **/
1987static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
1988			      struct ipr_hostrcb_config_element *cfg)
1989{
1990	int i, j;
1991	u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
1992	u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
1993
1994	if (type == IPR_PATH_CFG_NOT_EXIST)
1995		return;
1996
1997	for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
1998		if (path_type_desc[i].type != type)
1999			continue;
2000
2001		for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2002			if (path_status_desc[j].status != status)
2003				continue;
2004
2005			if (type == IPR_PATH_CFG_IOA_PORT) {
2006				ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
2007					     path_status_desc[j].desc, path_type_desc[i].desc,
2008					     cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2009					     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2010			} else {
2011				if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
2012					ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
2013						     path_status_desc[j].desc, path_type_desc[i].desc,
2014						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2015						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2016				} else if (cfg->cascaded_expander == 0xff) {
2017					ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
2018						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2019						     path_type_desc[i].desc, cfg->phy,
2020						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2021						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2022				} else if (cfg->phy == 0xff) {
2023					ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
2024						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2025						     path_type_desc[i].desc, cfg->cascaded_expander,
2026						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2027						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2028				} else {
2029					ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
2030						     "WWN=%08X%08X\n", path_status_desc[j].desc,
2031						     path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
2032						     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2033						     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2034				}
2035			}
2036			return;
2037		}
2038	}
2039
2040	ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
2041		     "WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
2042		     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2043		     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2044}
2045
2046/**
2047 * ipr_log64_path_elem - Log a fabric path element.
2048 * @hostrcb:	hostrcb struct
2049 * @cfg:		fabric path element struct
2050 *
2051 * Return value:
2052 * 	none
2053 **/
2054static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
2055				struct ipr_hostrcb64_config_element *cfg)
2056{
2057	int i, j;
2058	u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
2059	u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
2060	u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
2061	char buffer[IPR_MAX_RES_PATH_LENGTH];
2062
2063	if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
2064		return;
2065
2066	for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
2067		if (path_type_desc[i].type != type)
2068			continue;
2069
2070		for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
2071			if (path_status_desc[j].status != status)
2072				continue;
2073
2074			ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
2075				     path_status_desc[j].desc, path_type_desc[i].desc,
2076				     ipr_format_res_path(cfg->res_path, buffer,
2077							 sizeof(buffer)),
2078				     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2079				     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2080			return;
2081		}
2082	}
2083	ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
2084		     "WWN=%08X%08X\n", cfg->type_status,
2085		     ipr_format_res_path(cfg->res_path, buffer, sizeof(buffer)),
2086		     link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
2087		     be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
2088}
2089
2090/**
2091 * ipr_log_fabric_error - Log a fabric error.
2092 * @ioa_cfg:	ioa config struct
2093 * @hostrcb:	hostrcb struct
2094 *
2095 * Return value:
2096 * 	none
2097 **/
2098static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2099				 struct ipr_hostrcb *hostrcb)
2100{
2101	struct ipr_hostrcb_type_20_error *error;
2102	struct ipr_hostrcb_fabric_desc *fabric;
2103	struct ipr_hostrcb_config_element *cfg;
2104	int i, add_len;
2105
2106	error = &hostrcb->hcam.u.error.u.type_20_error;
2107	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2108	ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2109
2110	add_len = be32_to_cpu(hostrcb->hcam.length) -
2111		(offsetof(struct ipr_hostrcb_error, u) +
2112		 offsetof(struct ipr_hostrcb_type_20_error, desc));
2113
2114	for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2115		ipr_log_fabric_path(hostrcb, fabric);
2116		for_each_fabric_cfg(fabric, cfg)
2117			ipr_log_path_elem(hostrcb, cfg);
2118
2119		add_len -= be16_to_cpu(fabric->length);
2120		fabric = (struct ipr_hostrcb_fabric_desc *)
2121			((unsigned long)fabric + be16_to_cpu(fabric->length));
2122	}
2123
2124	ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2125}
2126
2127/**
2128 * ipr_log_sis64_array_error - Log a sis64 array error.
2129 * @ioa_cfg:	ioa config struct
2130 * @hostrcb:	hostrcb struct
2131 *
2132 * Return value:
2133 * 	none
2134 **/
2135static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
2136				      struct ipr_hostrcb *hostrcb)
2137{
2138	int i, num_entries;
2139	struct ipr_hostrcb_type_24_error *error;
2140	struct ipr_hostrcb64_array_data_entry *array_entry;
2141	char buffer[IPR_MAX_RES_PATH_LENGTH];
2142	const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
2143
2144	error = &hostrcb->hcam.u.error64.u.type_24_error;
2145
2146	ipr_err_separator;
2147
2148	ipr_err("RAID %s Array Configuration: %s\n",
2149		error->protection_level,
2150		ipr_format_res_path(error->last_res_path, buffer, sizeof(buffer)));
2151
2152	ipr_err_separator;
2153
2154	array_entry = error->array_member;
2155	num_entries = min_t(u32, error->num_entries,
2156			    ARRAY_SIZE(error->array_member));
2157
2158	for (i = 0; i < num_entries; i++, array_entry++) {
2159
2160		if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
2161			continue;
2162
2163		if (error->exposed_mode_adn == i)
2164			ipr_err("Exposed Array Member %d:\n", i);
2165		else
2166			ipr_err("Array Member %d:\n", i);
2167
2168		ipr_err("Array Member %d:\n", i);
2169		ipr_log_ext_vpd(&array_entry->vpd);
2170		ipr_err("Current Location: %s\n",
2171			 ipr_format_res_path(array_entry->res_path, buffer,
2172					     sizeof(buffer)));
2173		ipr_err("Expected Location: %s\n",
2174			 ipr_format_res_path(array_entry->expected_res_path,
2175					     buffer, sizeof(buffer)));
2176
2177		ipr_err_separator;
2178	}
2179}
2180
2181/**
2182 * ipr_log_sis64_fabric_error - Log a sis64 fabric error.
2183 * @ioa_cfg:	ioa config struct
2184 * @hostrcb:	hostrcb struct
2185 *
2186 * Return value:
2187 * 	none
2188 **/
2189static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
2190				       struct ipr_hostrcb *hostrcb)
2191{
2192	struct ipr_hostrcb_type_30_error *error;
2193	struct ipr_hostrcb64_fabric_desc *fabric;
2194	struct ipr_hostrcb64_config_element *cfg;
2195	int i, add_len;
2196
2197	error = &hostrcb->hcam.u.error64.u.type_30_error;
2198
2199	error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
2200	ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
2201
2202	add_len = be32_to_cpu(hostrcb->hcam.length) -
2203		(offsetof(struct ipr_hostrcb64_error, u) +
2204		 offsetof(struct ipr_hostrcb_type_30_error, desc));
2205
2206	for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
2207		ipr_log64_fabric_path(hostrcb, fabric);
2208		for_each_fabric_cfg(fabric, cfg)
2209			ipr_log64_path_elem(hostrcb, cfg);
2210
2211		add_len -= be16_to_cpu(fabric->length);
2212		fabric = (struct ipr_hostrcb64_fabric_desc *)
2213			((unsigned long)fabric + be16_to_cpu(fabric->length));
2214	}
2215
2216	ipr_log_hex_data(ioa_cfg, (u32 *)fabric, add_len);
2217}
2218
2219/**
2220 * ipr_log_generic_error - Log an adapter error.
2221 * @ioa_cfg:	ioa config struct
2222 * @hostrcb:	hostrcb struct
2223 *
2224 * Return value:
2225 * 	none
2226 **/
2227static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
2228				  struct ipr_hostrcb *hostrcb)
2229{
2230	ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
2231			 be32_to_cpu(hostrcb->hcam.length));
2232}
2233
2234/**
2235 * ipr_get_error - Find the specfied IOASC in the ipr_error_table.
2236 * @ioasc:	IOASC
2237 *
2238 * This function will return the index of into the ipr_error_table
2239 * for the specified IOASC. If the IOASC is not in the table,
2240 * 0 will be returned, which points to the entry used for unknown errors.
2241 *
2242 * Return value:
2243 * 	index into the ipr_error_table
2244 **/
2245static u32 ipr_get_error(u32 ioasc)
2246{
2247	int i;
2248
2249	for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
2250		if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
2251			return i;
2252
2253	return 0;
2254}
2255
2256/**
2257 * ipr_handle_log_data - Log an adapter error.
2258 * @ioa_cfg:	ioa config struct
2259 * @hostrcb:	hostrcb struct
2260 *
2261 * This function logs an adapter error to the system.
2262 *
2263 * Return value:
2264 * 	none
2265 **/
2266static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
2267				struct ipr_hostrcb *hostrcb)
2268{
2269	u32 ioasc;
2270	int error_index;
2271
2272	if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
2273		return;
2274
2275	if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
2276		dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
2277
2278	if (ioa_cfg->sis64)
2279		ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2280	else
2281		ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2282
2283	if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
2284	    ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
2285		/* Tell the midlayer we had a bus reset so it will handle the UA properly */
2286		scsi_report_bus_reset(ioa_cfg->host,
2287				      hostrcb->hcam.u.error.fd_res_addr.bus);
2288	}
2289
2290	error_index = ipr_get_error(ioasc);
2291
2292	if (!ipr_error_table[error_index].log_hcam)
2293		return;
2294
2295	ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
2296
2297	/* Set indication we have logged an error */
2298	ioa_cfg->errors_logged++;
2299
2300	if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
2301		return;
2302	if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
2303		hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
2304
2305	switch (hostrcb->hcam.overlay_id) {
2306	case IPR_HOST_RCB_OVERLAY_ID_2:
2307		ipr_log_cache_error(ioa_cfg, hostrcb);
2308		break;
2309	case IPR_HOST_RCB_OVERLAY_ID_3:
2310		ipr_log_config_error(ioa_cfg, hostrcb);
2311		break;
2312	case IPR_HOST_RCB_OVERLAY_ID_4:
2313	case IPR_HOST_RCB_OVERLAY_ID_6:
2314		ipr_log_array_error(ioa_cfg, hostrcb);
2315		break;
2316	case IPR_HOST_RCB_OVERLAY_ID_7:
2317		ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
2318		break;
2319	case IPR_HOST_RCB_OVERLAY_ID_12:
2320		ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
2321		break;
2322	case IPR_HOST_RCB_OVERLAY_ID_13:
2323		ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
2324		break;
2325	case IPR_HOST_RCB_OVERLAY_ID_14:
2326	case IPR_HOST_RCB_OVERLAY_ID_16:
2327		ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
2328		break;
2329	case IPR_HOST_RCB_OVERLAY_ID_17:
2330		ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
2331		break;
2332	case IPR_HOST_RCB_OVERLAY_ID_20:
2333		ipr_log_fabric_error(ioa_cfg, hostrcb);
2334		break;
2335	case IPR_HOST_RCB_OVERLAY_ID_23:
2336		ipr_log_sis64_config_error(ioa_cfg, hostrcb);
2337		break;
2338	case IPR_HOST_RCB_OVERLAY_ID_24:
2339	case IPR_HOST_RCB_OVERLAY_ID_26:
2340		ipr_log_sis64_array_error(ioa_cfg, hostrcb);
2341		break;
2342	case IPR_HOST_RCB_OVERLAY_ID_30:
2343		ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
2344		break;
2345	case IPR_HOST_RCB_OVERLAY_ID_1:
2346	case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
2347	default:
2348		ipr_log_generic_error(ioa_cfg, hostrcb);
2349		break;
2350	}
2351}
2352
2353/**
2354 * ipr_process_error - Op done function for an adapter error log.
2355 * @ipr_cmd:	ipr command struct
2356 *
2357 * This function is the op done function for an error log host
2358 * controlled async from the adapter. It will log the error and
2359 * send the HCAM back to the adapter.
2360 *
2361 * Return value:
2362 * 	none
2363 **/
2364static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
2365{
2366	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2367	struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
2368	u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
2369	u32 fd_ioasc;
2370
2371	if (ioa_cfg->sis64)
2372		fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
2373	else
2374		fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
2375
2376	list_del(&hostrcb->queue);
2377	list_add_tail(&ipr_cmd->queue, &ioa_cfg->free_q);
2378
2379	if (!ioasc) {
2380		ipr_handle_log_data(ioa_cfg, hostrcb);
2381		if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
2382			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
2383	} else if (ioasc != IPR_IOASC_IOA_WAS_RESET) {
2384		dev_err(&ioa_cfg->pdev->dev,
2385			"Host RCB failed with IOASC: 0x%08X\n", ioasc);
2386	}
2387
2388	ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
2389}
2390
2391/**
2392 * ipr_timeout -  An internally generated op has timed out.
2393 * @ipr_cmd:	ipr command struct
2394 *
2395 * This function blocks host requests and initiates an
2396 * adapter reset.
2397 *
2398 * Return value:
2399 * 	none
2400 **/
2401static void ipr_timeout(struct ipr_cmnd *ipr_cmd)
2402{
2403	unsigned long lock_flags = 0;
2404	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2405
2406	ENTER;
2407	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2408
2409	ioa_cfg->errors_logged++;
2410	dev_err(&ioa_cfg->pdev->dev,
2411		"Adapter being reset due to command timeout.\n");
2412
2413	if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2414		ioa_cfg->sdt_state = GET_DUMP;
2415
2416	if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
2417		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2418
2419	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2420	LEAVE;
2421}
2422
2423/**
2424 * ipr_oper_timeout -  Adapter timed out transitioning to operational
2425 * @ipr_cmd:	ipr command struct
2426 *
2427 * This function blocks host requests and initiates an
2428 * adapter reset.
2429 *
2430 * Return value:
2431 * 	none
2432 **/
2433static void ipr_oper_timeout(struct ipr_cmnd *ipr_cmd)
2434{
2435	unsigned long lock_flags = 0;
2436	struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
2437
2438	ENTER;
2439	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2440
2441	ioa_cfg->errors_logged++;
2442	dev_err(&ioa_cfg->pdev->dev,
2443		"Adapter timed out transitioning to operational.\n");
2444
2445	if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
2446		ioa_cfg->sdt_state = GET_DUMP;
2447
2448	if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
2449		if (ipr_fastfail)
2450			ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
2451		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
2452	}
2453
2454	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2455	LEAVE;
2456}
2457
2458/**
2459 * ipr_reset_reload - Reset/Reload the IOA
2460 * @ioa_cfg:		ioa config struct
2461 * @shutdown_type:	shutdown type
2462 *
2463 * This function resets the adapter and re-initializes it.
2464 * This function assumes that all new host commands have been stopped.
2465 * Return value:
2466 * 	SUCCESS / FAILED
2467 **/
2468static int ipr_reset_reload(struct ipr_ioa_cfg *ioa_cfg,
2469			    enum ipr_shutdown_type shutdown_type)
2470{
2471	if (!ioa_cfg->in_reset_reload)
2472		ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
2473
2474	spin_unlock_irq(ioa_cfg->host->host_lock);
2475	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
2476	spin_lock_irq(ioa_cfg->host->host_lock);
2477
2478	/* If we got hit with a host reset while we were already resetting
2479	 the adapter for some reason, and the reset failed. */
2480	if (ioa_cfg->ioa_is_dead) {
2481		ipr_trace;
2482		return FAILED;
2483	}
2484
2485	return SUCCESS;
2486}
2487
2488/**
2489 * ipr_find_ses_entry - Find matching SES in SES table
2490 * @res:	resource entry struct of SES
2491 *
2492 * Return value:
2493 * 	pointer to SES table entry / NULL on failure
2494 **/
2495static const struct ipr_ses_table_entry *
2496ipr_find_ses_entry(struct ipr_resource_entry *res)
2497{
2498	int i, j, matches;
2499	struct ipr_std_inq_vpids *vpids;
2500	const struct ipr_ses_table_entry *ste = ipr_ses_table;
2501
2502	for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
2503		for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
2504			if (ste->compare_product_id_byte[j] == 'X') {
2505				vpids = &res->std_inq_data.vpids;
2506				if (vpids->product_id[j] == ste->product_id[j])
2507					matches++;
2508				else
2509					break;
2510			} else
2511				matches++;
2512		}
2513
2514		if (matches == IPR_PROD_ID_LEN)
2515			return ste;
2516	}
2517
2518	return NULL;
2519}
2520
2521/**
2522 * ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
2523 * @ioa_cfg:	ioa config struct
2524 * @bus:		SCSI bus
2525 * @bus_width:	bus width
2526 *
2527 * Return value:
2528 *	SCSI bus speed in units of 100KHz, 1600 is 160 MHz
2529 *	For a 2-byte wide SCSI bus, the maximum transfer speed is
2530 *	twice the maximum transfer rate (e.g. for a wide enabled bus,
2531 *	max 160MHz = max 320MB/sec).
2532 **/
2533static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
2534{
2535	struct ipr_resource_entry *res;
2536	const struct ipr_ses_table_entry *ste;
2537	u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
2538
2539	/* Loop through each config table entry in the config table buffer */
2540	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
2541		if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
2542			continue;
2543
2544		if (bus != res->bus)
2545			continue;
2546
2547		if (!(ste = ipr_find_ses_entry(res)))
2548			continue;
2549
2550		max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
2551	}
2552
2553	return max_xfer_rate;
2554}
2555
2556/**
2557 * ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
2558 * @ioa_cfg:		ioa config struct
2559 * @max_delay:		max delay in micro-seconds to wait
2560 *
2561 * Waits for an IODEBUG ACK from the IOA, doing busy looping.
2562 *
2563 * Return value:
2564 * 	0 on success / other on failure
2565 **/
2566static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
2567{
2568	volatile u32 pcii_reg;
2569	int delay = 1;
2570
2571	/* Read interrupt reg until IOA signals IO Debug Acknowledge */
2572	while (delay < max_delay) {
2573		pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
2574
2575		if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
2576			return 0;
2577
2578		/* udelay cannot be used if delay is more than a few milliseconds */
2579		if ((delay / 1000) > MAX_UDELAY_MS)
2580			mdelay(delay / 1000);
2581		else
2582			udelay(delay);
2583
2584		delay += delay;
2585	}
2586	return -EIO;
2587}
2588
2589/**
2590 * ipr_get_sis64_dump_data_section - Dump IOA memory
2591 * @ioa_cfg:			ioa config struct
2592 * @start_addr:			adapter address to dump
2593 * @dest:			destination kernel buffer
2594 * @length_in_words:		length to dump in 4 byte words
2595 *
2596 * Return value:
2597 * 	0 on success
2598 **/
2599static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2600					   u32 start_addr,
2601					   __be32 *dest, u32 length_in_words)
2602{
2603	int i;
2604
2605	for (i = 0; i < length_in_words; i++) {
2606		writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
2607		*dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
2608		dest++;
2609	}
2610
2611	return 0;
2612}
2613
2614/**
2615 * ipr_get_ldump_data_section - Dump IOA memory
2616 * @ioa_cfg:			ioa config struct
2617 * @start_addr:			adapter address to dump
2618 * @dest:				destination kernel buffer
2619 * @length_in_words:	length to dump in 4 byte words
2620 *
2621 * Return value:
2622 * 	0 on success / -EIO on failure
2623 **/
2624static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
2625				      u32 start_addr,
2626				      __be32 *dest, u32 length_in_words)
2627{
2628	volatile u32 temp_pcii_reg;
2629	int i, delay = 0;
2630
2631	if (ioa_cfg->sis64)
2632		return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
2633						       dest, length_in_words);
2634
2635	/* Write IOA interrupt reg starting LDUMP state  */
2636	writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
2637	       ioa_cfg->regs.set_uproc_interrupt_reg32);
2638
2639	/* Wait for IO debug acknowledge */
2640	if (ipr_wait_iodbg_ack(ioa_cfg,
2641			       IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
2642		dev_err(&ioa_cfg->pdev->dev,
2643			"IOA dump long data transfer timeout\n");
2644		return -EIO;
2645	}
2646
2647	/* Signal LDUMP interlocked - clear IO debug ack */
2648	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2649	       ioa_cfg->regs.clr_interrupt_reg);
2650
2651	/* Write Mailbox with starting address */
2652	writel(start_addr, ioa_cfg->ioa_mailbox);
2653
2654	/* Signal address valid - clear IOA Reset alert */
2655	writel(IPR_UPROCI_RESET_ALERT,
2656	       ioa_cfg->regs.clr_uproc_interrupt_reg32);
2657
2658	for (i = 0; i < length_in_words; i++) {
2659		/* Wait for IO debug acknowledge */
2660		if (ipr_wait_iodbg_ack(ioa_cfg,
2661				       IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
2662			dev_err(&ioa_cfg->pdev->dev,
2663				"IOA dump short data transfer timeout\n");
2664			return -EIO;
2665		}
2666
2667		/* Read data from mailbox and increment destination pointer */
2668		*dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
2669		dest++;
2670
2671		/* For all but the last word of data, signal data received */
2672		if (i < (length_in_words - 1)) {
2673			/* Signal dump data received - Clear IO debug Ack */
2674			writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2675			       ioa_cfg->regs.clr_interrupt_reg);
2676		}
2677	}
2678
2679	/* Signal end of block transfer. Set reset alert then clear IO debug ack */
2680	writel(IPR_UPROCI_RESET_ALERT,
2681	       ioa_cfg->regs.set_uproc_interrupt_reg32);
2682
2683	writel(IPR_UPROCI_IO_DEBUG_ALERT,
2684	       ioa_cfg->regs.clr_uproc_interrupt_reg32);
2685
2686	/* Signal dump data received - Clear IO debug Ack */
2687	writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
2688	       ioa_cfg->regs.clr_interrupt_reg);
2689
2690	/* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
2691	while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
2692		temp_pcii_reg =
2693		    readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
2694
2695		if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
2696			return 0;
2697
2698		udelay(10);
2699		delay += 10;
2700	}
2701
2702	return 0;
2703}
2704
2705#ifdef CONFIG_SCSI_IPR_DUMP
2706/**
2707 * ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
2708 * @ioa_cfg:		ioa config struct
2709 * @pci_address:	adapter address
2710 * @length:			length of data to copy
2711 *
2712 * Copy data from PCI adapter to kernel buffer.
2713 * Note: length MUST be a 4 byte multiple
2714 * Return value:
2715 * 	0 on success / other on failure
2716 **/
2717static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
2718			unsigned long pci_address, u32 length)
2719{
2720	int bytes_copied = 0;
2721	int cur_len, rc, rem_len, rem_page_len, max_dump_size;
2722	__be32 *page;
2723	unsigned long lock_flags = 0;
2724	struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
2725
2726	if (ioa_cfg->sis64)
2727		max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2728	else
2729		max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2730
2731	while (bytes_copied < length &&
2732	       (ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
2733		if (ioa_dump->page_offset >= PAGE_SIZE ||
2734		    ioa_dump->page_offset == 0) {
2735			page = (__be32 *)__get_free_page(GFP_ATOMIC);
2736
2737			if (!page) {
2738				ipr_trace;
2739				return bytes_copied;
2740			}
2741
2742			ioa_dump->page_offset = 0;
2743			ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
2744			ioa_dump->next_page_index++;
2745		} else
2746			page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
2747
2748		rem_len = length - bytes_copied;
2749		rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
2750		cur_len = min(rem_len, rem_page_len);
2751
2752		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2753		if (ioa_cfg->sdt_state == ABORT_DUMP) {
2754			rc = -EIO;
2755		} else {
2756			rc = ipr_get_ldump_data_section(ioa_cfg,
2757							pci_address + bytes_copied,
2758							&page[ioa_dump->page_offset / 4],
2759							(cur_len / sizeof(u32)));
2760		}
2761		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2762
2763		if (!rc) {
2764			ioa_dump->page_offset += cur_len;
2765			bytes_copied += cur_len;
2766		} else {
2767			ipr_trace;
2768			break;
2769		}
2770		schedule();
2771	}
2772
2773	return bytes_copied;
2774}
2775
2776/**
2777 * ipr_init_dump_entry_hdr - Initialize a dump entry header.
2778 * @hdr:	dump entry header struct
2779 *
2780 * Return value:
2781 * 	nothing
2782 **/
2783static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
2784{
2785	hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
2786	hdr->num_elems = 1;
2787	hdr->offset = sizeof(*hdr);
2788	hdr->status = IPR_DUMP_STATUS_SUCCESS;
2789}
2790
2791/**
2792 * ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
2793 * @ioa_cfg:	ioa config struct
2794 * @driver_dump:	driver dump struct
2795 *
2796 * Return value:
2797 * 	nothing
2798 **/
2799static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
2800				   struct ipr_driver_dump *driver_dump)
2801{
2802	struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
2803
2804	ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
2805	driver_dump->ioa_type_entry.hdr.len =
2806		sizeof(struct ipr_dump_ioa_type_entry) -
2807		sizeof(struct ipr_dump_entry_header);
2808	driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2809	driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
2810	driver_dump->ioa_type_entry.type = ioa_cfg->type;
2811	driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
2812		(ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
2813		ucode_vpd->minor_release[1];
2814	driver_dump->hdr.num_entries++;
2815}
2816
2817/**
2818 * ipr_dump_version_data - Fill in the driver version in the dump.
2819 * @ioa_cfg:	ioa config struct
2820 * @driver_dump:	driver dump struct
2821 *
2822 * Return value:
2823 * 	nothing
2824 **/
2825static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
2826				  struct ipr_driver_dump *driver_dump)
2827{
2828	ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
2829	driver_dump->version_entry.hdr.len =
2830		sizeof(struct ipr_dump_version_entry) -
2831		sizeof(struct ipr_dump_entry_header);
2832	driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2833	driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
2834	strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
2835	driver_dump->hdr.num_entries++;
2836}
2837
2838/**
2839 * ipr_dump_trace_data - Fill in the IOA trace in the dump.
2840 * @ioa_cfg:	ioa config struct
2841 * @driver_dump:	driver dump struct
2842 *
2843 * Return value:
2844 * 	nothing
2845 **/
2846static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
2847				   struct ipr_driver_dump *driver_dump)
2848{
2849	ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
2850	driver_dump->trace_entry.hdr.len =
2851		sizeof(struct ipr_dump_trace_entry) -
2852		sizeof(struct ipr_dump_entry_header);
2853	driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2854	driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
2855	memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
2856	driver_dump->hdr.num_entries++;
2857}
2858
2859/**
2860 * ipr_dump_location_data - Fill in the IOA location in the dump.
2861 * @ioa_cfg:	ioa config struct
2862 * @driver_dump:	driver dump struct
2863 *
2864 * Return value:
2865 * 	nothing
2866 **/
2867static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
2868				   struct ipr_driver_dump *driver_dump)
2869{
2870	ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
2871	driver_dump->location_entry.hdr.len =
2872		sizeof(struct ipr_dump_location_entry) -
2873		sizeof(struct ipr_dump_entry_header);
2874	driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
2875	driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
2876	strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
2877	driver_dump->hdr.num_entries++;
2878}
2879
2880/**
2881 * ipr_get_ioa_dump - Perform a dump of the driver and adapter.
2882 * @ioa_cfg:	ioa config struct
2883 * @dump:		dump struct
2884 *
2885 * Return value:
2886 * 	nothing
2887 **/
2888static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
2889{
2890	unsigned long start_addr, sdt_word;
2891	unsigned long lock_flags = 0;
2892	struct ipr_driver_dump *driver_dump = &dump->driver_dump;
2893	struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
2894	u32 num_entries, max_num_entries, start_off, end_off;
2895	u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
2896	struct ipr_sdt *sdt;
2897	int valid = 1;
2898	int i;
2899
2900	ENTER;
2901
2902	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2903
2904	if (ioa_cfg->sdt_state != GET_DUMP) {
2905		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2906		return;
2907	}
2908
2909	if (ioa_cfg->sis64) {
2910		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2911		ssleep(IPR_DUMP_DELAY_SECONDS);
2912		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
2913	}
2914
2915	start_addr = readl(ioa_cfg->ioa_mailbox);
2916
2917	if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
2918		dev_err(&ioa_cfg->pdev->dev,
2919			"Invalid dump table format: %lx\n", start_addr);
2920		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2921		return;
2922	}
2923
2924	dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
2925
2926	driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
2927
2928	/* Initialize the overall dump header */
2929	driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
2930	driver_dump->hdr.num_entries = 1;
2931	driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
2932	driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
2933	driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
2934	driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
2935
2936	ipr_dump_version_data(ioa_cfg, driver_dump);
2937	ipr_dump_location_data(ioa_cfg, driver_dump);
2938	ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
2939	ipr_dump_trace_data(ioa_cfg, driver_dump);
2940
2941	/* Update dump_header */
2942	driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
2943
2944	/* IOA Dump entry */
2945	ipr_init_dump_entry_hdr(&ioa_dump->hdr);
2946	ioa_dump->hdr.len = 0;
2947	ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
2948	ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
2949
2950	/* First entries in sdt are actually a list of dump addresses and
2951	 lengths to gather the real dump data.  sdt represents the pointer
2952	 to the ioa generated dump table.  Dump data will be extracted based
2953	 on entries in this table */
2954	sdt = &ioa_dump->sdt;
2955
2956	if (ioa_cfg->sis64) {
2957		max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
2958		max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
2959	} else {
2960		max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
2961		max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
2962	}
2963
2964	bytes_to_copy = offsetof(struct ipr_sdt, entry) +
2965			(max_num_entries * sizeof(struct ipr_sdt_entry));
2966	rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
2967					bytes_to_copy / sizeof(__be32));
2968
2969	/* Smart Dump table is ready to use and the first entry is valid */
2970	if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
2971	    (be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
2972		dev_err(&ioa_cfg->pdev->dev,
2973			"Dump of IOA failed. Dump table not valid: %d, %X.\n",
2974			rc, be32_to_cpu(sdt->hdr.state));
2975		driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
2976		ioa_cfg->sdt_state = DUMP_OBTAINED;
2977		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2978		return;
2979	}
2980
2981	num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
2982
2983	if (num_entries > max_num_entries)
2984		num_entries = max_num_entries;
2985
2986	/* Update dump length to the actual data to be copied */
2987	dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
2988	if (ioa_cfg->sis64)
2989		dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
2990	else
2991		dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
2992
2993	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
2994
2995	for (i = 0; i < num_entries; i++) {
2996		if (ioa_dump->hdr.len > max_dump_size) {
2997			driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
2998			break;
2999		}
3000
3001		if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
3002			sdt_word = be32_to_cpu(sdt->entry[i].start_token);
3003			if (ioa_cfg->sis64)
3004				bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
3005			else {
3006				start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
3007				end_off = be32_to_cpu(sdt->entry[i].end_token);
3008
3009				if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
3010					bytes_to_copy = end_off - start_off;
3011				else
3012					valid = 0;
3013			}
3014			if (valid) {
3015				if (bytes_to_copy > max_dump_size) {
3016					sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
3017					continue;
3018				}
3019
3020				/* Copy data from adapter to driver buffers */
3021				bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
3022							    bytes_to_copy);
3023
3024				ioa_dump->hdr.len += bytes_copied;
3025
3026				if (bytes_copied != bytes_to_copy) {
3027					driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
3028					break;
3029				}
3030			}
3031		}
3032	}
3033
3034	dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
3035
3036	/* Update dump_header */
3037	driver_dump->hdr.len += ioa_dump->hdr.len;
3038	wmb();
3039	ioa_cfg->sdt_state = DUMP_OBTAINED;
3040	LEAVE;
3041}
3042
3043#else
3044#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while(0)
3045#endif
3046
3047/**
3048 * ipr_release_dump - Free adapter dump memory
3049 * @kref:	kref struct
3050 *
3051 * Return value:
3052 *	nothing
3053 **/
3054static void ipr_release_dump(struct kref *kref)
3055{
3056	struct ipr_dump *dump = container_of(kref,struct ipr_dump,kref);
3057	struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
3058	unsigned long lock_flags = 0;
3059	int i;
3060
3061	ENTER;
3062	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3063	ioa_cfg->dump = NULL;
3064	ioa_cfg->sdt_state = INACTIVE;
3065	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3066
3067	for (i = 0; i < dump->ioa_dump.next_page_index; i++)
3068		free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
3069
3070	vfree(dump->ioa_dump.ioa_data);
3071	kfree(dump);
3072	LEAVE;
3073}
3074
3075/**
3076 * ipr_worker_thread - Worker thread
3077 * @work:		ioa config struct
3078 *
3079 * Called at task level from a work thread. This function takes care
3080 * of adding and removing device from the mid-layer as configuration
3081 * changes are detected by the adapter.
3082 *
3083 * Return value:
3084 * 	nothing
3085 **/
3086static void ipr_worker_thread(struct work_struct *work)
3087{
3088	unsigned long lock_flags;
3089	struct ipr_resource_entry *res;
3090	struct scsi_device *sdev;
3091	struct ipr_dump *dump;
3092	struct ipr_ioa_cfg *ioa_cfg =
3093		container_of(work, struct ipr_ioa_cfg, work_q);
3094	u8 bus, target, lun;
3095	int did_work;
3096
3097	ENTER;
3098	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3099
3100	if (ioa_cfg->sdt_state == GET_DUMP) {
3101		dump = ioa_cfg->dump;
3102		if (!dump) {
3103			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3104			return;
3105		}
3106		kref_get(&dump->kref);
3107		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3108		ipr_get_ioa_dump(ioa_cfg, dump);
3109		kref_put(&dump->kref, ipr_release_dump);
3110
3111		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3112		if (ioa_cfg->sdt_state == DUMP_OBTAINED)
3113			ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3114		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3115		return;
3116	}
3117
3118restart:
3119	do {
3120		did_work = 0;
3121		if (!ioa_cfg->allow_cmds || !ioa_cfg->allow_ml_add_del) {
3122			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3123			return;
3124		}
3125
3126		list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3127			if (res->del_from_ml && res->sdev) {
3128				did_work = 1;
3129				sdev = res->sdev;
3130				if (!scsi_device_get(sdev)) {
3131					if (!res->add_to_ml)
3132						list_move_tail(&res->queue, &ioa_cfg->free_res_q);
3133					else
3134						res->del_from_ml = 0;
3135					spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3136					scsi_remove_device(sdev);
3137					scsi_device_put(sdev);
3138					spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3139				}
3140				break;
3141			}
3142		}
3143	} while(did_work);
3144
3145	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
3146		if (res->add_to_ml) {
3147			bus = res->bus;
3148			target = res->target;
3149			lun = res->lun;
3150			res->add_to_ml = 0;
3151			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3152			scsi_add_device(ioa_cfg->host, bus, target, lun);
3153			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3154			goto restart;
3155		}
3156	}
3157
3158	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3159	kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
3160	LEAVE;
3161}
3162
3163#ifdef CONFIG_SCSI_IPR_TRACE
3164/**
3165 * ipr_read_trace - Dump the adapter trace
3166 * @filp:		open sysfs file
3167 * @kobj:		kobject struct
3168 * @bin_attr:		bin_attribute struct
3169 * @buf:		buffer
3170 * @off:		offset
3171 * @count:		buffer size
3172 *
3173 * Return value:
3174 *	number of bytes printed to buffer
3175 **/
3176static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
3177			      struct bin_attribute *bin_attr,
3178			      char *buf, loff_t off, size_t count)
3179{
3180	struct device *dev = container_of(kobj, struct device, kobj);
3181	struct Scsi_Host *shost = class_to_shost(dev);
3182	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3183	unsigned long lock_flags = 0;
3184	ssize_t ret;
3185
3186	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3187	ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
3188				IPR_TRACE_SIZE);
3189	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3190
3191	return ret;
3192}
3193
3194static struct bin_attribute ipr_trace_attr = {
3195	.attr =	{
3196		.name = "trace",
3197		.mode = S_IRUGO,
3198	},
3199	.size = 0,
3200	.read = ipr_read_trace,
3201};
3202#endif
3203
3204/**
3205 * ipr_show_fw_version - Show the firmware version
3206 * @dev:	class device struct
3207 * @buf:	buffer
3208 *
3209 * Return value:
3210 *	number of bytes printed to buffer
3211 **/
3212static ssize_t ipr_show_fw_version(struct device *dev,
3213				   struct device_attribute *attr, char *buf)
3214{
3215	struct Scsi_Host *shost = class_to_shost(dev);
3216	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3217	struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
3218	unsigned long lock_flags = 0;
3219	int len;
3220
3221	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3222	len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
3223		       ucode_vpd->major_release, ucode_vpd->card_type,
3224		       ucode_vpd->minor_release[0],
3225		       ucode_vpd->minor_release[1]);
3226	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3227	return len;
3228}
3229
3230static struct device_attribute ipr_fw_version_attr = {
3231	.attr = {
3232		.name =		"fw_version",
3233		.mode =		S_IRUGO,
3234	},
3235	.show = ipr_show_fw_version,
3236};
3237
3238/**
3239 * ipr_show_log_level - Show the adapter's error logging level
3240 * @dev:	class device struct
3241 * @buf:	buffer
3242 *
3243 * Return value:
3244 * 	number of bytes printed to buffer
3245 **/
3246static ssize_t ipr_show_log_level(struct device *dev,
3247				   struct device_attribute *attr, char *buf)
3248{
3249	struct Scsi_Host *shost = class_to_shost(dev);
3250	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3251	unsigned long lock_flags = 0;
3252	int len;
3253
3254	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3255	len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
3256	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3257	return len;
3258}
3259
3260/**
3261 * ipr_store_log_level - Change the adapter's error logging level
3262 * @dev:	class device struct
3263 * @buf:	buffer
3264 *
3265 * Return value:
3266 * 	number of bytes printed to buffer
3267 **/
3268static ssize_t ipr_store_log_level(struct device *dev,
3269			           struct device_attribute *attr,
3270				   const char *buf, size_t count)
3271{
3272	struct Scsi_Host *shost = class_to_shost(dev);
3273	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3274	unsigned long lock_flags = 0;
3275
3276	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3277	ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
3278	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3279	return strlen(buf);
3280}
3281
3282static struct device_attribute ipr_log_level_attr = {
3283	.attr = {
3284		.name =		"log_level",
3285		.mode =		S_IRUGO | S_IWUSR,
3286	},
3287	.show = ipr_show_log_level,
3288	.store = ipr_store_log_level
3289};
3290
3291/**
3292 * ipr_store_diagnostics - IOA Diagnostics interface
3293 * @dev:	device struct
3294 * @buf:	buffer
3295 * @count:	buffer size
3296 *
3297 * This function will reset the adapter and wait a reasonable
3298 * amount of time for any errors that the adapter might log.
3299 *
3300 * Return value:
3301 * 	count on success / other on failure
3302 **/
3303static ssize_t ipr_store_diagnostics(struct device *dev,
3304				     struct device_attribute *attr,
3305				     const char *buf, size_t count)
3306{
3307	struct Scsi_Host *shost = class_to_shost(dev);
3308	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3309	unsigned long lock_flags = 0;
3310	int rc = count;
3311
3312	if (!capable(CAP_SYS_ADMIN))
3313		return -EACCES;
3314
3315	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3316	while(ioa_cfg->in_reset_reload) {
3317		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3318		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3319		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3320	}
3321
3322	ioa_cfg->errors_logged = 0;
3323	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3324
3325	if (ioa_cfg->in_reset_reload) {
3326		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3327		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3328
3329		/* Wait for a second for any errors to be logged */
3330		msleep(1000);
3331	} else {
3332		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3333		return -EIO;
3334	}
3335
3336	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3337	if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
3338		rc = -EIO;
3339	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3340
3341	return rc;
3342}
3343
3344static struct device_attribute ipr_diagnostics_attr = {
3345	.attr = {
3346		.name =		"run_diagnostics",
3347		.mode =		S_IWUSR,
3348	},
3349	.store = ipr_store_diagnostics
3350};
3351
3352/**
3353 * ipr_show_adapter_state - Show the adapter's state
3354 * @class_dev:	device struct
3355 * @buf:	buffer
3356 *
3357 * Return value:
3358 * 	number of bytes printed to buffer
3359 **/
3360static ssize_t ipr_show_adapter_state(struct device *dev,
3361				      struct device_attribute *attr, char *buf)
3362{
3363	struct Scsi_Host *shost = class_to_shost(dev);
3364	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3365	unsigned long lock_flags = 0;
3366	int len;
3367
3368	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3369	if (ioa_cfg->ioa_is_dead)
3370		len = snprintf(buf, PAGE_SIZE, "offline\n");
3371	else
3372		len = snprintf(buf, PAGE_SIZE, "online\n");
3373	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3374	return len;
3375}
3376
3377/**
3378 * ipr_store_adapter_state - Change adapter state
3379 * @dev:	device struct
3380 * @buf:	buffer
3381 * @count:	buffer size
3382 *
3383 * This function will change the adapter's state.
3384 *
3385 * Return value:
3386 * 	count on success / other on failure
3387 **/
3388static ssize_t ipr_store_adapter_state(struct device *dev,
3389				       struct device_attribute *attr,
3390				       const char *buf, size_t count)
3391{
3392	struct Scsi_Host *shost = class_to_shost(dev);
3393	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3394	unsigned long lock_flags;
3395	int result = count;
3396
3397	if (!capable(CAP_SYS_ADMIN))
3398		return -EACCES;
3399
3400	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3401	if (ioa_cfg->ioa_is_dead && !strncmp(buf, "online", 6)) {
3402		ioa_cfg->ioa_is_dead = 0;
3403		ioa_cfg->reset_retries = 0;
3404		ioa_cfg->in_ioa_bringdown = 0;
3405		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
3406	}
3407	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3408	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3409
3410	return result;
3411}
3412
3413static struct device_attribute ipr_ioa_state_attr = {
3414	.attr = {
3415		.name =		"online_state",
3416		.mode =		S_IRUGO | S_IWUSR,
3417	},
3418	.show = ipr_show_adapter_state,
3419	.store = ipr_store_adapter_state
3420};
3421
3422/**
3423 * ipr_store_reset_adapter - Reset the adapter
3424 * @dev:	device struct
3425 * @buf:	buffer
3426 * @count:	buffer size
3427 *
3428 * This function will reset the adapter.
3429 *
3430 * Return value:
3431 * 	count on success / other on failure
3432 **/
3433static ssize_t ipr_store_reset_adapter(struct device *dev,
3434				       struct device_attribute *attr,
3435				       const char *buf, size_t count)
3436{
3437	struct Scsi_Host *shost = class_to_shost(dev);
3438	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3439	unsigned long lock_flags;
3440	int result = count;
3441
3442	if (!capable(CAP_SYS_ADMIN))
3443		return -EACCES;
3444
3445	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3446	if (!ioa_cfg->in_reset_reload)
3447		ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3448	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3449	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3450
3451	return result;
3452}
3453
3454static struct device_attribute ipr_ioa_reset_attr = {
3455	.attr = {
3456		.name =		"reset_host",
3457		.mode =		S_IWUSR,
3458	},
3459	.store = ipr_store_reset_adapter
3460};
3461
3462/**
3463 * ipr_alloc_ucode_buffer - Allocates a microcode download buffer
3464 * @buf_len:		buffer length
3465 *
3466 * Allocates a DMA'able buffer in chunks and assembles a scatter/gather
3467 * list to use for microcode download
3468 *
3469 * Return value:
3470 * 	pointer to sglist / NULL on failure
3471 **/
3472static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
3473{
3474	int sg_size, order, bsize_elem, num_elem, i, j;
3475	struct ipr_sglist *sglist;
3476	struct scatterlist *scatterlist;
3477	struct page *page;
3478
3479	/* Get the minimum size per scatter/gather element */
3480	sg_size = buf_len / (IPR_MAX_SGLIST - 1);
3481
3482	/* Get the actual size per element */
3483	order = get_order(sg_size);
3484
3485	/* Determine the actual number of bytes per element */
3486	bsize_elem = PAGE_SIZE * (1 << order);
3487
3488	/* Determine the actual number of sg entries needed */
3489	if (buf_len % bsize_elem)
3490		num_elem = (buf_len / bsize_elem) + 1;
3491	else
3492		num_elem = buf_len / bsize_elem;
3493
3494	/* Allocate a scatter/gather list for the DMA */
3495	sglist = kzalloc(sizeof(struct ipr_sglist) +
3496			 (sizeof(struct scatterlist) * (num_elem - 1)),
3497			 GFP_KERNEL);
3498
3499	if (sglist == NULL) {
3500		ipr_trace;
3501		return NULL;
3502	}
3503
3504	scatterlist = sglist->scatterlist;
3505	sg_init_table(scatterlist, num_elem);
3506
3507	sglist->order = order;
3508	sglist->num_sg = num_elem;
3509
3510	/* Allocate a bunch of sg elements */
3511	for (i = 0; i < num_elem; i++) {
3512		page = alloc_pages(GFP_KERNEL, order);
3513		if (!page) {
3514			ipr_trace;
3515
3516			/* Free up what we already allocated */
3517			for (j = i - 1; j >= 0; j--)
3518				__free_pages(sg_page(&scatterlist[j]), order);
3519			kfree(sglist);
3520			return NULL;
3521		}
3522
3523		sg_set_page(&scatterlist[i], page, 0, 0);
3524	}
3525
3526	return sglist;
3527}
3528
3529/**
3530 * ipr_free_ucode_buffer - Frees a microcode download buffer
3531 * @p_dnld:		scatter/gather list pointer
3532 *
3533 * Free a DMA'able ucode download buffer previously allocated with
3534 * ipr_alloc_ucode_buffer
3535 *
3536 * Return value:
3537 * 	nothing
3538 **/
3539static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
3540{
3541	int i;
3542
3543	for (i = 0; i < sglist->num_sg; i++)
3544		__free_pages(sg_page(&sglist->scatterlist[i]), sglist->order);
3545
3546	kfree(sglist);
3547}
3548
3549/**
3550 * ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
3551 * @sglist:		scatter/gather list pointer
3552 * @buffer:		buffer pointer
3553 * @len:		buffer length
3554 *
3555 * Copy a microcode image from a user buffer into a buffer allocated by
3556 * ipr_alloc_ucode_buffer
3557 *
3558 * Return value:
3559 * 	0 on success / other on failure
3560 **/
3561static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
3562				 u8 *buffer, u32 len)
3563{
3564	int bsize_elem, i, result = 0;
3565	struct scatterlist *scatterlist;
3566	void *kaddr;
3567
3568	/* Determine the actual number of bytes per element */
3569	bsize_elem = PAGE_SIZE * (1 << sglist->order);
3570
3571	scatterlist = sglist->scatterlist;
3572
3573	for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
3574		struct page *page = sg_page(&scatterlist[i]);
3575
3576		kaddr = kmap(page);
3577		memcpy(kaddr, buffer, bsize_elem);
3578		kunmap(page);
3579
3580		scatterlist[i].length = bsize_elem;
3581
3582		if (result != 0) {
3583			ipr_trace;
3584			return result;
3585		}
3586	}
3587
3588	if (len % bsize_elem) {
3589		struct page *page = sg_page(&scatterlist[i]);
3590
3591		kaddr = kmap(page);
3592		memcpy(kaddr, buffer, len % bsize_elem);
3593		kunmap(page);
3594
3595		scatterlist[i].length = len % bsize_elem;
3596	}
3597
3598	sglist->buffer_len = len;
3599	return result;
3600}
3601
3602/**
3603 * ipr_build_ucode_ioadl64 - Build a microcode download IOADL
3604 * @ipr_cmd:		ipr command struct
3605 * @sglist:		scatter/gather list
3606 *
3607 * Builds a microcode download IOA data list (IOADL).
3608 *
3609 **/
3610static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
3611				    struct ipr_sglist *sglist)
3612{
3613	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3614	struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
3615	struct scatterlist *scatterlist = sglist->scatterlist;
3616	int i;
3617
3618	ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3619	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3620	ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3621
3622	ioarcb->ioadl_len =
3623		cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
3624	for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3625		ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
3626		ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
3627		ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
3628	}
3629
3630	ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3631}
3632
3633/**
3634 * ipr_build_ucode_ioadl - Build a microcode download IOADL
3635 * @ipr_cmd:	ipr command struct
3636 * @sglist:		scatter/gather list
3637 *
3638 * Builds a microcode download IOA data list (IOADL).
3639 *
3640 **/
3641static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
3642				  struct ipr_sglist *sglist)
3643{
3644	struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
3645	struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
3646	struct scatterlist *scatterlist = sglist->scatterlist;
3647	int i;
3648
3649	ipr_cmd->dma_use_sg = sglist->num_dma_sg;
3650	ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
3651	ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
3652
3653	ioarcb->ioadl_len =
3654		cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
3655
3656	for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
3657		ioadl[i].flags_and_data_len =
3658			cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
3659		ioadl[i].address =
3660			cpu_to_be32(sg_dma_address(&scatterlist[i]));
3661	}
3662
3663	ioadl[i-1].flags_and_data_len |=
3664		cpu_to_be32(IPR_IOADL_FLAGS_LAST);
3665}
3666
3667/**
3668 * ipr_update_ioa_ucode - Update IOA's microcode
3669 * @ioa_cfg:	ioa config struct
3670 * @sglist:		scatter/gather list
3671 *
3672 * Initiate an adapter reset to update the IOA's microcode
3673 *
3674 * Return value:
3675 * 	0 on success / -EIO on failure
3676 **/
3677static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
3678				struct ipr_sglist *sglist)
3679{
3680	unsigned long lock_flags;
3681
3682	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3683	while(ioa_cfg->in_reset_reload) {
3684		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3685		wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3686		spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3687	}
3688
3689	if (ioa_cfg->ucode_sglist) {
3690		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3691		dev_err(&ioa_cfg->pdev->dev,
3692			"Microcode download already in progress\n");
3693		return -EIO;
3694	}
3695
3696	sglist->num_dma_sg = pci_map_sg(ioa_cfg->pdev, sglist->scatterlist,
3697					sglist->num_sg, DMA_TO_DEVICE);
3698
3699	if (!sglist->num_dma_sg) {
3700		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3701		dev_err(&ioa_cfg->pdev->dev,
3702			"Failed to map microcode download buffer!\n");
3703		return -EIO;
3704	}
3705
3706	ioa_cfg->ucode_sglist = sglist;
3707	ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
3708	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3709	wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
3710
3711	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3712	ioa_cfg->ucode_sglist = NULL;
3713	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3714	return 0;
3715}
3716
3717/**
3718 * ipr_store_update_fw - Update the firmware on the adapter
3719 * @class_dev:	device struct
3720 * @buf:	buffer
3721 * @count:	buffer size
3722 *
3723 * This function will update the firmware on the adapter.
3724 *
3725 * Return value:
3726 * 	count on success / other on failure
3727 **/
3728static ssize_t ipr_store_update_fw(struct device *dev,
3729				   struct device_attribute *attr,
3730				   const char *buf, size_t count)
3731{
3732	struct Scsi_Host *shost = class_to_shost(dev);
3733	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3734	struct ipr_ucode_image_header *image_hdr;
3735	const struct firmware *fw_entry;
3736	struct ipr_sglist *sglist;
3737	char fname[100];
3738	char *src;
3739	int len, result, dnld_size;
3740
3741	if (!capable(CAP_SYS_ADMIN))
3742		return -EACCES;
3743
3744	len = snprintf(fname, 99, "%s", buf);
3745	fname[len-1] = '\0';
3746
3747	if(request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
3748		dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
3749		return -EIO;
3750	}
3751
3752	image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
3753
3754	if (be32_to_cpu(image_hdr->header_length) > fw_entry->size ||
3755	    (ioa_cfg->vpd_cbs->page3_data.card_type &&
3756	     ioa_cfg->vpd_cbs->page3_data.card_type != image_hdr->card_type)) {
3757		dev_err(&ioa_cfg->pdev->dev, "Invalid microcode buffer\n");
3758		release_firmware(fw_entry);
3759		return -EINVAL;
3760	}
3761
3762	src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
3763	dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
3764	sglist = ipr_alloc_ucode_buffer(dnld_size);
3765
3766	if (!sglist) {
3767		dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
3768		release_firmware(fw_entry);
3769		return -ENOMEM;
3770	}
3771
3772	result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
3773
3774	if (result) {
3775		dev_err(&ioa_cfg->pdev->dev,
3776			"Microcode buffer copy to DMA buffer failed\n");
3777		goto out;
3778	}
3779
3780	result = ipr_update_ioa_ucode(ioa_cfg, sglist);
3781
3782	if (!result)
3783		result = count;
3784out:
3785	ipr_free_ucode_buffer(sglist);
3786	release_firmware(fw_entry);
3787	return result;
3788}
3789
3790static struct device_attribute ipr_update_fw_attr = {
3791	.attr = {
3792		.name =		"update_fw",
3793		.mode =		S_IWUSR,
3794	},
3795	.store = ipr_store_update_fw
3796};
3797
3798/**
3799 * ipr_show_fw_type - Show the adapter's firmware type.
3800 * @dev:	class device struct
3801 * @buf:	buffer
3802 *
3803 * Return value:
3804 *	number of bytes printed to buffer
3805 **/
3806static ssize_t ipr_show_fw_type(struct device *dev,
3807				struct device_attribute *attr, char *buf)
3808{
3809	struct Scsi_Host *shost = class_to_shost(dev);
3810	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3811	unsigned long lock_flags = 0;
3812	int len;
3813
3814	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3815	len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
3816	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3817	return len;
3818}
3819
3820static struct device_attribute ipr_ioa_fw_type_attr = {
3821	.attr = {
3822		.name =		"fw_type",
3823		.mode =		S_IRUGO,
3824	},
3825	.show = ipr_show_fw_type
3826};
3827
3828static struct device_attribute *ipr_ioa_attrs[] = {
3829	&ipr_fw_version_attr,
3830	&ipr_log_level_attr,
3831	&ipr_diagnostics_attr,
3832	&ipr_ioa_state_attr,
3833	&ipr_ioa_reset_attr,
3834	&ipr_update_fw_attr,
3835	&ipr_ioa_fw_type_attr,
3836	NULL,
3837};
3838
3839#ifdef CONFIG_SCSI_IPR_DUMP
3840/**
3841 * ipr_read_dump - Dump the adapter
3842 * @filp:		open sysfs file
3843 * @kobj:		kobject struct
3844 * @bin_attr:		bin_attribute struct
3845 * @buf:		buffer
3846 * @off:		offset
3847 * @count:		buffer size
3848 *
3849 * Return value:
3850 *	number of bytes printed to buffer
3851 **/
3852static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
3853			     struct bin_attribute *bin_attr,
3854			     char *buf, loff_t off, size_t count)
3855{
3856	struct device *cdev = container_of(kobj, struct device, kobj);
3857	struct Scsi_Host *shost = class_to_shost(cdev);
3858	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
3859	struct ipr_dump *dump;
3860	unsigned long lock_flags = 0;
3861	char *src;
3862	int len, sdt_end;
3863	size_t rc = count;
3864
3865	if (!capable(CAP_SYS_ADMIN))
3866		return -EACCES;
3867
3868	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3869	dump = ioa_cfg->dump;
3870
3871	if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
3872		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3873		return 0;
3874	}
3875	kref_get(&dump->kref);
3876	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3877
3878	if (off > dump->driver_dump.hdr.len) {
3879		kref_put(&dump->kref, ipr_release_dump);
3880		return 0;
3881	}
3882
3883	if (off + count > dump->driver_dump.hdr.len) {
3884		count = dump->driver_dump.hdr.len - off;
3885		rc = count;
3886	}
3887
3888	if (count && off < sizeof(dump->driver_dump)) {
3889		if (off + count > sizeof(dump->driver_dump))
3890			len = sizeof(dump->driver_dump) - off;
3891		else
3892			len = count;
3893		src = (u8 *)&dump->driver_dump + off;
3894		memcpy(buf, src, len);
3895		buf += len;
3896		off += len;
3897		count -= len;
3898	}
3899
3900	off -= sizeof(dump->driver_dump);
3901
3902	if (ioa_cfg->sis64)
3903		sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
3904			  (be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
3905			   sizeof(struct ipr_sdt_entry));
3906	else
3907		sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
3908			  (IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
3909
3910	if (count && off < sdt_end) {
3911		if (off + count > sdt_end)
3912			len = sdt_end - off;
3913		else
3914			len = count;
3915		src = (u8 *)&dump->ioa_dump + off;
3916		memcpy(buf, src, len);
3917		buf += len;
3918		off += len;
3919		count -= len;
3920	}
3921
3922	off -= sdt_end;
3923
3924	while (count) {
3925		if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
3926			len = PAGE_ALIGN(off) - off;
3927		else
3928			len = count;
3929		src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
3930		src += off & ~PAGE_MASK;
3931		memcpy(buf, src, len);
3932		buf += len;
3933		off += len;
3934		count -= len;
3935	}
3936
3937	kref_put(&dump->kref, ipr_release_dump);
3938	return rc;
3939}
3940
3941/**
3942 * ipr_alloc_dump - Prepare for adapter dump
3943 * @ioa_cfg:	ioa config struct
3944 *
3945 * Return value:
3946 *	0 on success / other on failure
3947 **/
3948static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
3949{
3950	struct ipr_dump *dump;
3951	__be32 **ioa_data;
3952	unsigned long lock_flags = 0;
3953
3954	dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
3955
3956	if (!dump) {
3957		ipr_err("Dump memory allocation failed\n");
3958		return -ENOMEM;
3959	}
3960
3961	if (ioa_cfg->sis64)
3962		ioa_data = vmalloc(IPR_FMT3_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
3963	else
3964		ioa_data = vmalloc(IPR_FMT2_MAX_NUM_DUMP_PAGES * sizeof(__be32 *));
3965
3966	if (!ioa_data) {
3967		ipr_err("Dump memory allocation failed\n");
3968		kfree(dump);
3969		return -ENOMEM;
3970	}
3971
3972	dump->ioa_dump.ioa_data = ioa_data;
3973
3974	kref_init(&dump->kref);
3975	dump->ioa_cfg = ioa_cfg;
3976
3977	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
3978
3979	if (INACTIVE != ioa_cfg->sdt_state) {
3980		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3981		vfree(dump->ioa_dump.ioa_data);
3982		kfree(dump);
3983		return 0;
3984	}
3985
3986	ioa_cfg->dump = dump;
3987	ioa_cfg->sdt_state = WAIT_FOR_DUMP;
3988	if (ioa_cfg->ioa_is_dead && !ioa_cfg->dump_taken) {
3989		ioa_cfg->dump_taken = 1;
3990		schedule_work(&ioa_cfg->work_q);
3991	}
3992	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
3993
3994	return 0;
3995}
3996
3997/**
3998 * ipr_free_dump - Free adapter dump memory
3999 * @ioa_cfg:	ioa config struct
4000 *
4001 * Return value:
4002 *	0 on success / other on failure
4003 **/
4004static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
4005{
4006	struct ipr_dump *dump;
4007	unsigned long lock_flags = 0;
4008
4009	ENTER;
4010
4011	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4012	dump = ioa_cfg->dump;
4013	if (!dump) {
4014		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4015		return 0;
4016	}
4017
4018	ioa_cfg->dump = NULL;
4019	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4020
4021	kref_put(&dump->kref, ipr_release_dump);
4022
4023	LEAVE;
4024	return 0;
4025}
4026
4027/**
4028 * ipr_write_dump - Setup dump state of adapter
4029 * @filp:		open sysfs file
4030 * @kobj:		kobject struct
4031 * @bin_attr:		bin_attribute struct
4032 * @buf:		buffer
4033 * @off:		offset
4034 * @count:		buffer size
4035 *
4036 * Return value:
4037 *	number of bytes printed to buffer
4038 **/
4039static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
4040			      struct bin_attribute *bin_attr,
4041			      char *buf, loff_t off, size_t count)
4042{
4043	struct device *cdev = container_of(kobj, struct device, kobj);
4044	struct Scsi_Host *shost = class_to_shost(cdev);
4045	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
4046	int rc;
4047
4048	if (!capable(CAP_SYS_ADMIN))
4049		return -EACCES;
4050
4051	if (buf[0] == '1')
4052		rc = ipr_alloc_dump(ioa_cfg);
4053	else if (buf[0] == '0')
4054		rc = ipr_free_dump(ioa_cfg);
4055	else
4056		return -EINVAL;
4057
4058	if (rc)
4059		return rc;
4060	else
4061		return count;
4062}
4063
4064static struct bin_attribute ipr_dump_attr = {
4065	.attr =	{
4066		.name = "dump",
4067		.mode = S_IRUSR | S_IWUSR,
4068	},
4069	.size = 0,
4070	.read = ipr_read_dump,
4071	.write = ipr_write_dump
4072};
4073#else
4074static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
4075#endif
4076
4077/**
4078 * ipr_change_queue_depth - Change the device's queue depth
4079 * @sdev:	scsi device struct
4080 * @qdepth:	depth to set
4081 * @reason:	calling context
4082 *
4083 * Return value:
4084 * 	actual depth set
4085 **/
4086static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth,
4087				  int reason)
4088{
4089	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4090	struct ipr_resource_entry *res;
4091	unsigned long lock_flags = 0;
4092
4093	if (reason != SCSI_QDEPTH_DEFAULT)
4094		return -EOPNOTSUPP;
4095
4096	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4097	res = (struct ipr_resource_entry *)sdev->hostdata;
4098
4099	if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
4100		qdepth = IPR_MAX_CMD_PER_ATA_LUN;
4101	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4102
4103	scsi_adjust_queue_depth(sdev, scsi_get_tag_type(sdev), qdepth);
4104	return sdev->queue_depth;
4105}
4106
4107/**
4108 * ipr_change_queue_type - Change the device's queue type
4109 * @dsev:		scsi device struct
4110 * @tag_type:	type of tags to use
4111 *
4112 * Return value:
4113 * 	actual queue type set
4114 **/
4115static int ipr_change_queue_type(struct scsi_device *sdev, int tag_type)
4116{
4117	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4118	struct ipr_resource_entry *res;
4119	unsigned long lock_flags = 0;
4120
4121	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4122	res = (struct ipr_resource_entry *)sdev->hostdata;
4123
4124	if (res) {
4125		if (ipr_is_gscsi(res) && sdev->tagged_supported) {
4126			/*
4127			 * We don't bother quiescing the device here since the
4128			 * adapter firmware does it for us.
4129			 */
4130			scsi_set_tag_type(sdev, tag_type);
4131
4132			if (tag_type)
4133				scsi_activate_tcq(sdev, sdev->queue_depth);
4134			else
4135				scsi_deactivate_tcq(sdev, sdev->queue_depth);
4136		} else
4137			tag_type = 0;
4138	} else
4139		tag_type = 0;
4140
4141	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4142	return tag_type;
4143}
4144
4145/**
4146 * ipr_show_adapter_handle - Show the adapter's resource handle for this device
4147 * @dev:	device struct
4148 * @attr:	device attribute structure
4149 * @buf:	buffer
4150 *
4151 * Return value:
4152 * 	number of bytes printed to buffer
4153 **/
4154static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
4155{
4156	struct scsi_device *sdev = to_scsi_device(dev);
4157	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4158	struct ipr_resource_entry *res;
4159	unsigned long lock_flags = 0;
4160	ssize_t len = -ENXIO;
4161
4162	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4163	res = (struct ipr_resource_entry *)sdev->hostdata;
4164	if (res)
4165		len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
4166	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4167	return len;
4168}
4169
4170static struct device_attribute ipr_adapter_handle_attr = {
4171	.attr = {
4172		.name = 	"adapter_handle",
4173		.mode =		S_IRUSR,
4174	},
4175	.show = ipr_show_adapter_handle
4176};
4177
4178/**
4179 * ipr_show_resource_path - Show the resource path or the resource address for
4180 *			    this device.
4181 * @dev:	device struct
4182 * @attr:	device attribute structure
4183 * @buf:	buffer
4184 *
4185 * Return value:
4186 * 	number of bytes printed to buffer
4187 **/
4188static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
4189{
4190	struct scsi_device *sdev = to_scsi_device(dev);
4191	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4192	struct ipr_resource_entry *res;
4193	unsigned long lock_flags = 0;
4194	ssize_t len = -ENXIO;
4195	char buffer[IPR_MAX_RES_PATH_LENGTH];
4196
4197	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4198	res = (struct ipr_resource_entry *)sdev->hostdata;
4199	if (res && ioa_cfg->sis64)
4200		len = snprintf(buf, PAGE_SIZE, "%s\n",
4201			       ipr_format_res_path(res->res_path, buffer,
4202						   sizeof(buffer)));
4203	else if (res)
4204		len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
4205			       res->bus, res->target, res->lun);
4206
4207	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4208	return len;
4209}
4210
4211static struct device_attribute ipr_resource_path_attr = {
4212	.attr = {
4213		.name = 	"resource_path",
4214		.mode =		S_IRUGO,
4215	},
4216	.show = ipr_show_resource_path
4217};
4218
4219/**
4220 * ipr_show_device_id - Show the device_id for this device.
4221 * @dev:	device struct
4222 * @attr:	device attribute structure
4223 * @buf:	buffer
4224 *
4225 * Return value:
4226 *	number of bytes printed to buffer
4227 **/
4228static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
4229{
4230	struct scsi_device *sdev = to_scsi_device(dev);
4231	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4232	struct ipr_resource_entry *res;
4233	unsigned long lock_flags = 0;
4234	ssize_t len = -ENXIO;
4235
4236	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4237	res = (struct ipr_resource_entry *)sdev->hostdata;
4238	if (res && ioa_cfg->sis64)
4239		len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->dev_id);
4240	else if (res)
4241		len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
4242
4243	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4244	return len;
4245}
4246
4247static struct device_attribute ipr_device_id_attr = {
4248	.attr = {
4249		.name =		"device_id",
4250		.mode =		S_IRUGO,
4251	},
4252	.show = ipr_show_device_id
4253};
4254
4255/**
4256 * ipr_show_resource_type - Show the resource type for this device.
4257 * @dev:	device struct
4258 * @attr:	device attribute structure
4259 * @buf:	buffer
4260 *
4261 * Return value:
4262 *	number of bytes printed to buffer
4263 **/
4264static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
4265{
4266	struct scsi_device *sdev = to_scsi_device(dev);
4267	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
4268	struct ipr_resource_entry *res;
4269	unsigned long lock_flags = 0;
4270	ssize_t len = -ENXIO;
4271
4272	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4273	res = (struct ipr_resource_entry *)sdev->hostdata;
4274
4275	if (res)
4276		len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
4277
4278	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4279	return len;
4280}
4281
4282static struct device_attribute ipr_resource_type_attr = {
4283	.attr = {
4284		.name =		"resource_type",
4285		.mode =		S_IRUGO,
4286	},
4287	.show = ipr_show_resource_type
4288};
4289
4290static struct device_attribute *ipr_dev_attrs[] = {
4291	&ipr_adapter_handle_attr,
4292	&ipr_resource_path_attr,
4293	&ipr_device_id_attr,
4294	&ipr_resource_type_attr,
4295	NULL,
4296};
4297
4298/**
4299 * ipr_biosparam - Return the HSC mapping
4300 * @sdev:			scsi device struct
4301 * @block_device:	block device pointer
4302 * @capacity:		capacity of the device
4303 * @parm:			Array containing returned HSC values.
4304 *
4305 * This function generates the HSC parms that fdisk uses.
4306 * We want to make sure we return something that places partitions
4307 * on 4k boundaries for best performance with the IOA.
4308 *
4309 * Return value:
4310 * 	0 on success
4311 **/
4312static int ipr_biosparam(struct scsi_device *sdev,
4313			 struct block_device *block_device,
4314			 sector_t capacity, int *parm)
4315{
4316	int heads, sectors;
4317	sector_t cylinders;
4318
4319	heads = 128;
4320	sectors = 32;
4321
4322	cylinders = capacity;
4323	sector_div(cylinders, (128 * 32));
4324
4325	/* return result */
4326	parm[0] = heads;
4327	parm[1] = sectors;
4328	parm[2] = cylinders;
4329
4330	return 0;
4331}
4332
4333/**
4334 * ipr_find_starget - Find target based on bus/target.
4335 * @starget:	scsi target struct
4336 *
4337 * Return value:
4338 * 	resource entry pointer if found / NULL if not found
4339 **/
4340static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
4341{
4342	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4343	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4344	struct ipr_resource_entry *res;
4345
4346	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4347		if ((res->bus == starget->channel) &&
4348		    (res->target == starget->id) &&
4349		    (res->lun == 0)) {
4350			return res;
4351		}
4352	}
4353
4354	return NULL;
4355}
4356
4357static struct ata_port_info sata_port_info;
4358
4359/**
4360 * ipr_target_alloc - Prepare for commands to a SCSI target
4361 * @starget:	scsi target struct
4362 *
4363 * If the device is a SATA device, this function allocates an
4364 * ATA port with libata, else it does nothing.
4365 *
4366 * Return value:
4367 * 	0 on success / non-0 on failure
4368 **/
4369static int ipr_target_alloc(struct scsi_target *starget)
4370{
4371	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4372	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4373	struct ipr_sata_port *sata_port;
4374	struct ata_port *ap;
4375	struct ipr_resource_entry *res;
4376	unsigned long lock_flags;
4377
4378	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4379	res = ipr_find_starget(starget);
4380	starget->hostdata = NULL;
4381
4382	if (res && ipr_is_gata(res)) {
4383		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4384		sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
4385		if (!sata_port)
4386			return -ENOMEM;
4387
4388		ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
4389		if (ap) {
4390			spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4391			sata_port->ioa_cfg = ioa_cfg;
4392			sata_port->ap = ap;
4393			sata_port->res = res;
4394
4395			res->sata_port = sata_port;
4396			ap->private_data = sata_port;
4397			starget->hostdata = sata_port;
4398		} else {
4399			kfree(sata_port);
4400			return -ENOMEM;
4401		}
4402	}
4403	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4404
4405	return 0;
4406}
4407
4408/**
4409 * ipr_target_destroy - Destroy a SCSI target
4410 * @starget:	scsi target struct
4411 *
4412 * If the device was a SATA device, this function frees the libata
4413 * ATA port, else it does nothing.
4414 *
4415 **/
4416static void ipr_target_destroy(struct scsi_target *starget)
4417{
4418	struct ipr_sata_port *sata_port = starget->hostdata;
4419	struct Scsi_Host *shost = dev_to_shost(&starget->dev);
4420	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
4421
4422	if (ioa_cfg->sis64) {
4423		if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
4424			clear_bit(starget->id, ioa_cfg->array_ids);
4425		else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
4426			clear_bit(starget->id, ioa_cfg->vset_ids);
4427		else if (starget->channel == 0)
4428			clear_bit(starget->id, ioa_cfg->target_ids);
4429	}
4430
4431	if (sata_port) {
4432		starget->hostdata = NULL;
4433		ata_sas_port_destroy(sata_port->ap);
4434		kfree(sata_port);
4435	}
4436}
4437
4438/**
4439 * ipr_find_sdev - Find device based on bus/target/lun.
4440 * @sdev:	scsi device struct
4441 *
4442 * Return value:
4443 * 	resource entry pointer if found / NULL if not found
4444 **/
4445static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
4446{
4447	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4448	struct ipr_resource_entry *res;
4449
4450	list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
4451		if ((res->bus == sdev->channel) &&
4452		    (res->target == sdev->id) &&
4453		    (res->lun == sdev->lun))
4454			return res;
4455	}
4456
4457	return NULL;
4458}
4459
4460/**
4461 * ipr_slave_destroy - Unconfigure a SCSI device
4462 * @sdev:	scsi device struct
4463 *
4464 * Return value:
4465 * 	nothing
4466 **/
4467static void ipr_slave_destroy(struct scsi_device *sdev)
4468{
4469	struct ipr_resource_entry *res;
4470	struct ipr_ioa_cfg *ioa_cfg;
4471	unsigned long lock_flags = 0;
4472
4473	ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4474
4475	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4476	res = (struct ipr_resource_entry *) sdev->hostdata;
4477	if (res) {
4478		if (res->sata_port)
4479			res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
4480		sdev->hostdata = NULL;
4481		res->sdev = NULL;
4482		res->sata_port = NULL;
4483	}
4484	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4485}
4486
4487/**
4488 * ipr_slave_configure - Configure a SCSI device
4489 * @sdev:	scsi device struct
4490 *
4491 * This function configures the specified scsi device.
4492 *
4493 * Return value:
4494 * 	0 on success
4495 **/
4496static int ipr_slave_configure(struct scsi_device *sdev)
4497{
4498	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4499	struct ipr_resource_entry *res;
4500	struct ata_port *ap = NULL;
4501	unsigned long lock_flags = 0;
4502	char buffer[IPR_MAX_RES_PATH_LENGTH];
4503
4504	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4505	res = sdev->hostdata;
4506	if (res) {
4507		if (ipr_is_af_dasd_device(res))
4508			sdev->type = TYPE_RAID;
4509		if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
4510			sdev->scsi_level = 4;
4511			sdev->no_uld_attach = 1;
4512		}
4513		if (ipr_is_vset_device(res)) {
4514			blk_queue_rq_timeout(sdev->request_queue,
4515					     IPR_VSET_RW_TIMEOUT);
4516			blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
4517		}
4518		if (ipr_is_gata(res) && res->sata_port)
4519			ap = res->sata_port->ap;
4520		spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4521
4522		if (ap) {
4523			scsi_adjust_queue_depth(sdev, 0, IPR_MAX_CMD_PER_ATA_LUN);
4524			ata_sas_slave_configure(sdev, ap);
4525		} else
4526			scsi_adjust_queue_depth(sdev, 0, sdev->host->cmd_per_lun);
4527		if (ioa_cfg->sis64)
4528			sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
4529				    ipr_format_res_path(res->res_path, buffer,
4530							sizeof(buffer)));
4531		return 0;
4532	}
4533	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4534	return 0;
4535}
4536
4537/**
4538 * ipr_ata_slave_alloc - Prepare for commands to a SATA device
4539 * @sdev:	scsi device struct
4540 *
4541 * This function initializes an ATA port so that future commands
4542 * sent through queuecommand will work.
4543 *
4544 * Return value:
4545 * 	0 on success
4546 **/
4547static int ipr_ata_slave_alloc(struct scsi_device *sdev)
4548{
4549	struct ipr_sata_port *sata_port = NULL;
4550	int rc = -ENXIO;
4551
4552	ENTER;
4553	if (sdev->sdev_target)
4554		sata_port = sdev->sdev_target->hostdata;
4555	if (sata_port)
4556		rc = ata_sas_port_init(sata_port->ap);
4557	if (rc)
4558		ipr_slave_destroy(sdev);
4559
4560	LEAVE;
4561	return rc;
4562}
4563
4564/**
4565 * ipr_slave_alloc - Prepare for commands to a device.
4566 * @sdev:	scsi device struct
4567 *
4568 * This function saves a pointer to the resource entry
4569 * in the scsi device struct if the device exists. We
4570 * can then use this pointer in ipr_queuecommand when
4571 * handling new commands.
4572 *
4573 * Return value:
4574 * 	0 on success / -ENXIO if device does not exist
4575 **/
4576static int ipr_slave_alloc(struct scsi_device *sdev)
4577{
4578	struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
4579	struct ipr_resource_entry *res;
4580	unsigned long lock_flags;
4581	int rc = -ENXIO;
4582
4583	sdev->hostdata = NULL;
4584
4585	spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
4586
4587	res = ipr_find_sdev(sdev);
4588	if (res) {
4589		res->sdev = sdev;
4590		res->add_to_ml = 0;
4591		res->in_erp = 0;
4592		sdev->hostdata = res;
4593		if (!ipr_is_naca_model(res))
4594			res->needs_sync_complete = 1;
4595		rc = 0;
4596		if (ipr_is_gata(res)) {
4597			spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4598			return ipr_ata_slave_alloc(sdev);
4599		}
4600	}
4601
4602	spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
4603
4604	return rc;
46