![Wen Xiong](/assets/img/avatar_default.png)
While dlpar adding primary ipr adapter back, driver goes through adapter initialization then schedule ipr_worker_thread to start te disk scan by dropping the host lock, calling scsi_add_device. Then get the adapter reset request again, so driver does scsi_block_requests, this will cause the scsi_add_device get hung until we unblock. But we can't run ipr_worker_thread to do the unblock because its stuck in scsi_add_device. This patch fixes the issue. [mkp: typo and whitespace fixes] Signed-off-by: Wen Xiong <wenxiong@linux.vnet.ibm.com> Acked-by: Brian King <brking@linux.vnet.ibm.com> Signed-off-by: Martin K. Petersen <martin.petersen@oracle.com>
10879 lines
302 KiB
C
10879 lines
302 KiB
C
/*
|
|
* ipr.c -- driver for IBM Power Linux RAID adapters
|
|
*
|
|
* Written By: Brian King <brking@us.ibm.com>, IBM Corporation
|
|
*
|
|
* Copyright (C) 2003, 2004 IBM Corporation
|
|
*
|
|
* This program is free software; you can redistribute it and/or modify
|
|
* it under the terms of the GNU General Public License as published by
|
|
* the Free Software Foundation; either version 2 of the License, or
|
|
* (at your option) any later version.
|
|
*
|
|
* This program is distributed in the hope that it will be useful,
|
|
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
* GNU General Public License for more details.
|
|
*
|
|
* You should have received a copy of the GNU General Public License
|
|
* along with this program; if not, write to the Free Software
|
|
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA
|
|
*
|
|
*/
|
|
|
|
/*
|
|
* Notes:
|
|
*
|
|
* This driver is used to control the following SCSI adapters:
|
|
*
|
|
* IBM iSeries: 5702, 5703, 2780, 5709, 570A, 570B
|
|
*
|
|
* IBM pSeries: PCI-X Dual Channel Ultra 320 SCSI RAID Adapter
|
|
* PCI-X Dual Channel Ultra 320 SCSI Adapter
|
|
* PCI-X Dual Channel Ultra 320 SCSI RAID Enablement Card
|
|
* Embedded SCSI adapter on p615 and p655 systems
|
|
*
|
|
* Supported Hardware Features:
|
|
* - Ultra 320 SCSI controller
|
|
* - PCI-X host interface
|
|
* - Embedded PowerPC RISC Processor and Hardware XOR DMA Engine
|
|
* - Non-Volatile Write Cache
|
|
* - Supports attachment of non-RAID disks, tape, and optical devices
|
|
* - RAID Levels 0, 5, 10
|
|
* - Hot spare
|
|
* - Background Parity Checking
|
|
* - Background Data Scrubbing
|
|
* - Ability to increase the capacity of an existing RAID 5 disk array
|
|
* by adding disks
|
|
*
|
|
* Driver Features:
|
|
* - Tagged command queuing
|
|
* - Adapter microcode download
|
|
* - PCI hot plug
|
|
* - SCSI device hot plug
|
|
*
|
|
*/
|
|
|
|
#include <linux/fs.h>
|
|
#include <linux/init.h>
|
|
#include <linux/types.h>
|
|
#include <linux/errno.h>
|
|
#include <linux/kernel.h>
|
|
#include <linux/slab.h>
|
|
#include <linux/vmalloc.h>
|
|
#include <linux/ioport.h>
|
|
#include <linux/delay.h>
|
|
#include <linux/pci.h>
|
|
#include <linux/wait.h>
|
|
#include <linux/spinlock.h>
|
|
#include <linux/sched.h>
|
|
#include <linux/interrupt.h>
|
|
#include <linux/blkdev.h>
|
|
#include <linux/firmware.h>
|
|
#include <linux/module.h>
|
|
#include <linux/moduleparam.h>
|
|
#include <linux/libata.h>
|
|
#include <linux/hdreg.h>
|
|
#include <linux/reboot.h>
|
|
#include <linux/stringify.h>
|
|
#include <asm/io.h>
|
|
#include <asm/irq.h>
|
|
#include <asm/processor.h>
|
|
#include <scsi/scsi.h>
|
|
#include <scsi/scsi_host.h>
|
|
#include <scsi/scsi_tcq.h>
|
|
#include <scsi/scsi_eh.h>
|
|
#include <scsi/scsi_cmnd.h>
|
|
#include "ipr.h"
|
|
|
|
/*
|
|
* Global Data
|
|
*/
|
|
static LIST_HEAD(ipr_ioa_head);
|
|
static unsigned int ipr_log_level = IPR_DEFAULT_LOG_LEVEL;
|
|
static unsigned int ipr_max_speed = 1;
|
|
static int ipr_testmode = 0;
|
|
static unsigned int ipr_fastfail = 0;
|
|
static unsigned int ipr_transop_timeout = 0;
|
|
static unsigned int ipr_debug = 0;
|
|
static unsigned int ipr_max_devs = IPR_DEFAULT_SIS64_DEVS;
|
|
static unsigned int ipr_dual_ioa_raid = 1;
|
|
static unsigned int ipr_number_of_msix = 16;
|
|
static unsigned int ipr_fast_reboot;
|
|
static DEFINE_SPINLOCK(ipr_driver_lock);
|
|
|
|
/* This table describes the differences between DMA controller chips */
|
|
static const struct ipr_chip_cfg_t ipr_chip_cfg[] = {
|
|
{ /* Gemstone, Citrine, Obsidian, and Obsidian-E */
|
|
.mailbox = 0x0042C,
|
|
.max_cmds = 100,
|
|
.cache_line_size = 0x20,
|
|
.clear_isr = 1,
|
|
.iopoll_weight = 0,
|
|
{
|
|
.set_interrupt_mask_reg = 0x0022C,
|
|
.clr_interrupt_mask_reg = 0x00230,
|
|
.clr_interrupt_mask_reg32 = 0x00230,
|
|
.sense_interrupt_mask_reg = 0x0022C,
|
|
.sense_interrupt_mask_reg32 = 0x0022C,
|
|
.clr_interrupt_reg = 0x00228,
|
|
.clr_interrupt_reg32 = 0x00228,
|
|
.sense_interrupt_reg = 0x00224,
|
|
.sense_interrupt_reg32 = 0x00224,
|
|
.ioarrin_reg = 0x00404,
|
|
.sense_uproc_interrupt_reg = 0x00214,
|
|
.sense_uproc_interrupt_reg32 = 0x00214,
|
|
.set_uproc_interrupt_reg = 0x00214,
|
|
.set_uproc_interrupt_reg32 = 0x00214,
|
|
.clr_uproc_interrupt_reg = 0x00218,
|
|
.clr_uproc_interrupt_reg32 = 0x00218
|
|
}
|
|
},
|
|
{ /* Snipe and Scamp */
|
|
.mailbox = 0x0052C,
|
|
.max_cmds = 100,
|
|
.cache_line_size = 0x20,
|
|
.clear_isr = 1,
|
|
.iopoll_weight = 0,
|
|
{
|
|
.set_interrupt_mask_reg = 0x00288,
|
|
.clr_interrupt_mask_reg = 0x0028C,
|
|
.clr_interrupt_mask_reg32 = 0x0028C,
|
|
.sense_interrupt_mask_reg = 0x00288,
|
|
.sense_interrupt_mask_reg32 = 0x00288,
|
|
.clr_interrupt_reg = 0x00284,
|
|
.clr_interrupt_reg32 = 0x00284,
|
|
.sense_interrupt_reg = 0x00280,
|
|
.sense_interrupt_reg32 = 0x00280,
|
|
.ioarrin_reg = 0x00504,
|
|
.sense_uproc_interrupt_reg = 0x00290,
|
|
.sense_uproc_interrupt_reg32 = 0x00290,
|
|
.set_uproc_interrupt_reg = 0x00290,
|
|
.set_uproc_interrupt_reg32 = 0x00290,
|
|
.clr_uproc_interrupt_reg = 0x00294,
|
|
.clr_uproc_interrupt_reg32 = 0x00294
|
|
}
|
|
},
|
|
{ /* CRoC */
|
|
.mailbox = 0x00044,
|
|
.max_cmds = 1000,
|
|
.cache_line_size = 0x20,
|
|
.clear_isr = 0,
|
|
.iopoll_weight = 64,
|
|
{
|
|
.set_interrupt_mask_reg = 0x00010,
|
|
.clr_interrupt_mask_reg = 0x00018,
|
|
.clr_interrupt_mask_reg32 = 0x0001C,
|
|
.sense_interrupt_mask_reg = 0x00010,
|
|
.sense_interrupt_mask_reg32 = 0x00014,
|
|
.clr_interrupt_reg = 0x00008,
|
|
.clr_interrupt_reg32 = 0x0000C,
|
|
.sense_interrupt_reg = 0x00000,
|
|
.sense_interrupt_reg32 = 0x00004,
|
|
.ioarrin_reg = 0x00070,
|
|
.sense_uproc_interrupt_reg = 0x00020,
|
|
.sense_uproc_interrupt_reg32 = 0x00024,
|
|
.set_uproc_interrupt_reg = 0x00020,
|
|
.set_uproc_interrupt_reg32 = 0x00024,
|
|
.clr_uproc_interrupt_reg = 0x00028,
|
|
.clr_uproc_interrupt_reg32 = 0x0002C,
|
|
.init_feedback_reg = 0x0005C,
|
|
.dump_addr_reg = 0x00064,
|
|
.dump_data_reg = 0x00068,
|
|
.endian_swap_reg = 0x00084
|
|
}
|
|
},
|
|
};
|
|
|
|
static const struct ipr_chip_t ipr_chip[] = {
|
|
{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E, true, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[0] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP, false, IPR_SIS32, IPR_PCI_CFG, &ipr_chip_cfg[1] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE, true, IPR_SIS64, IPR_MMIO, &ipr_chip_cfg[2] }
|
|
};
|
|
|
|
static int ipr_max_bus_speeds[] = {
|
|
IPR_80MBs_SCSI_RATE, IPR_U160_SCSI_RATE, IPR_U320_SCSI_RATE
|
|
};
|
|
|
|
MODULE_AUTHOR("Brian King <brking@us.ibm.com>");
|
|
MODULE_DESCRIPTION("IBM Power RAID SCSI Adapter Driver");
|
|
module_param_named(max_speed, ipr_max_speed, uint, 0);
|
|
MODULE_PARM_DESC(max_speed, "Maximum bus speed (0-2). Default: 1=U160. Speeds: 0=80 MB/s, 1=U160, 2=U320");
|
|
module_param_named(log_level, ipr_log_level, uint, 0);
|
|
MODULE_PARM_DESC(log_level, "Set to 0 - 4 for increasing verbosity of device driver");
|
|
module_param_named(testmode, ipr_testmode, int, 0);
|
|
MODULE_PARM_DESC(testmode, "DANGEROUS!!! Allows unsupported configurations");
|
|
module_param_named(fastfail, ipr_fastfail, int, S_IRUGO | S_IWUSR);
|
|
MODULE_PARM_DESC(fastfail, "Reduce timeouts and retries");
|
|
module_param_named(transop_timeout, ipr_transop_timeout, int, 0);
|
|
MODULE_PARM_DESC(transop_timeout, "Time in seconds to wait for adapter to come operational (default: 300)");
|
|
module_param_named(debug, ipr_debug, int, S_IRUGO | S_IWUSR);
|
|
MODULE_PARM_DESC(debug, "Enable device driver debugging logging. Set to 1 to enable. (default: 0)");
|
|
module_param_named(dual_ioa_raid, ipr_dual_ioa_raid, int, 0);
|
|
MODULE_PARM_DESC(dual_ioa_raid, "Enable dual adapter RAID support. Set to 1 to enable. (default: 1)");
|
|
module_param_named(max_devs, ipr_max_devs, int, 0);
|
|
MODULE_PARM_DESC(max_devs, "Specify the maximum number of physical devices. "
|
|
"[Default=" __stringify(IPR_DEFAULT_SIS64_DEVS) "]");
|
|
module_param_named(number_of_msix, ipr_number_of_msix, int, 0);
|
|
MODULE_PARM_DESC(number_of_msix, "Specify the number of MSIX interrupts to use on capable adapters (1 - 16). (default:16)");
|
|
module_param_named(fast_reboot, ipr_fast_reboot, int, S_IRUGO | S_IWUSR);
|
|
MODULE_PARM_DESC(fast_reboot, "Skip adapter shutdown during reboot. Set to 1 to enable. (default: 0)");
|
|
MODULE_LICENSE("GPL");
|
|
MODULE_VERSION(IPR_DRIVER_VERSION);
|
|
|
|
/* A constant array of IOASCs/URCs/Error Messages */
|
|
static const
|
|
struct ipr_error_table_t ipr_error_table[] = {
|
|
{0x00000000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"8155: An unknown error was received"},
|
|
{0x00330000, 0, 0,
|
|
"Soft underlength error"},
|
|
{0x005A0000, 0, 0,
|
|
"Command to be cancelled not found"},
|
|
{0x00808000, 0, 0,
|
|
"Qualified success"},
|
|
{0x01080000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFE: Soft device bus error recovered by the IOA"},
|
|
{0x01088100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4101: Soft device bus fabric error"},
|
|
{0x01100100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFC: Logical block guard error recovered by the device"},
|
|
{0x01100300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFC: Logical block reference tag error recovered by the device"},
|
|
{0x01108300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4171: Recovered scatter list tag / sequence number error"},
|
|
{0x01109000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FF3D: Recovered logical block CRC error on IOA to Host transfer"},
|
|
{0x01109200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4171: Recovered logical block sequence number error on IOA to Host transfer"},
|
|
{0x0110A000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFD: Recovered logical block reference tag error detected by the IOA"},
|
|
{0x0110A100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFD: Logical block guard error recovered by the IOA"},
|
|
{0x01170600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF9: Device sector reassign successful"},
|
|
{0x01170900, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF7: Media error recovered by device rewrite procedures"},
|
|
{0x01180200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"7001: IOA sector reassignment successful"},
|
|
{0x01180500, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF9: Soft media error. Sector reassignment recommended"},
|
|
{0x01180600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF7: Media error recovered by IOA rewrite procedures"},
|
|
{0x01418000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FF3D: Soft PCI bus error recovered by the IOA"},
|
|
{0x01440000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF6: Device hardware error recovered by the IOA"},
|
|
{0x01448100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF6: Device hardware error recovered by the device"},
|
|
{0x01448200, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FF3D: Soft IOA error recovered by the IOA"},
|
|
{0x01448300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFA: Undefined device response recovered by the IOA"},
|
|
{0x014A0000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF6: Device bus error, message or command phase"},
|
|
{0x014A8000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFE: Task Management Function failed"},
|
|
{0x015D0000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF6: Failure prediction threshold exceeded"},
|
|
{0x015D9200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"8009: Impending cache battery pack failure"},
|
|
{0x02040100, 0, 0,
|
|
"Logical Unit in process of becoming ready"},
|
|
{0x02040200, 0, 0,
|
|
"Initializing command required"},
|
|
{0x02040400, 0, 0,
|
|
"34FF: Disk device format in progress"},
|
|
{0x02040C00, 0, 0,
|
|
"Logical unit not accessible, target port in unavailable state"},
|
|
{0x02048000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9070: IOA requested reset"},
|
|
{0x023F0000, 0, 0,
|
|
"Synchronization required"},
|
|
{0x02408500, 0, 0,
|
|
"IOA microcode download required"},
|
|
{0x02408600, 0, 0,
|
|
"Device bus connection is prohibited by host"},
|
|
{0x024E0000, 0, 0,
|
|
"No ready, IOA shutdown"},
|
|
{0x025A0000, 0, 0,
|
|
"Not ready, IOA has been shutdown"},
|
|
{0x02670100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3020: Storage subsystem configuration error"},
|
|
{0x03110B00, 0, 0,
|
|
"FFF5: Medium error, data unreadable, recommend reassign"},
|
|
{0x03110C00, 0, 0,
|
|
"7000: Medium error, data unreadable, do not reassign"},
|
|
{0x03310000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF3: Disk media format bad"},
|
|
{0x04050000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3002: Addressed device failed to respond to selection"},
|
|
{0x04080000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"3100: Device bus error"},
|
|
{0x04080100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3109: IOA timed out a device command"},
|
|
{0x04088000, 0, 0,
|
|
"3120: SCSI bus is not operational"},
|
|
{0x04088100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4100: Hard device bus fabric error"},
|
|
{0x04100100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"310C: Logical block guard error detected by the device"},
|
|
{0x04100300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"310C: Logical block reference tag error detected by the device"},
|
|
{0x04108300, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"4170: Scatter list tag / sequence number error"},
|
|
{0x04109000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"8150: Logical block CRC error on IOA to Host transfer"},
|
|
{0x04109200, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"4170: Logical block sequence number error on IOA to Host transfer"},
|
|
{0x0410A000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"310D: Logical block reference tag error detected by the IOA"},
|
|
{0x0410A100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"310D: Logical block guard error detected by the IOA"},
|
|
{0x04118000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9000: IOA reserved area data check"},
|
|
{0x04118100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9001: IOA reserved area invalid data pattern"},
|
|
{0x04118200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9002: IOA reserved area LRC error"},
|
|
{0x04118300, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"Hardware Error, IOA metadata access error"},
|
|
{0x04320000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"102E: Out of alternate sectors for disk storage"},
|
|
{0x04330000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF4: Data transfer underlength error"},
|
|
{0x04338000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF4: Data transfer overlength error"},
|
|
{0x043E0100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3400: Logical unit failure"},
|
|
{0x04408500, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF4: Device microcode is corrupt"},
|
|
{0x04418000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"8150: PCI bus error"},
|
|
{0x04430000, 1, 0,
|
|
"Unsupported device bus message received"},
|
|
{0x04440000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF4: Disk device problem"},
|
|
{0x04448200, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"8150: Permanent IOA failure"},
|
|
{0x04448300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3010: Disk device returned wrong response to IOA"},
|
|
{0x04448400, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"8151: IOA microcode error"},
|
|
{0x04448500, 0, 0,
|
|
"Device bus status error"},
|
|
{0x04448600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"8157: IOA error requiring IOA reset to recover"},
|
|
{0x04448700, 0, 0,
|
|
"ATA device status error"},
|
|
{0x04490000, 0, 0,
|
|
"Message reject received from the device"},
|
|
{0x04449200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"8008: A permanent cache battery pack failure occurred"},
|
|
{0x0444A000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9090: Disk unit has been modified after the last known status"},
|
|
{0x0444A200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9081: IOA detected device error"},
|
|
{0x0444A300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9082: IOA detected device error"},
|
|
{0x044A0000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"3110: Device bus error, message or command phase"},
|
|
{0x044A8000, 1, IPR_DEFAULT_LOG_LEVEL,
|
|
"3110: SAS Command / Task Management Function failed"},
|
|
{0x04670400, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9091: Incorrect hardware configuration change has been detected"},
|
|
{0x04678000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9073: Invalid multi-adapter configuration"},
|
|
{0x04678100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4010: Incorrect connection between cascaded expanders"},
|
|
{0x04678200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4020: Connections exceed IOA design limits"},
|
|
{0x04678300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4030: Incorrect multipath connection"},
|
|
{0x04679000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4110: Unsupported enclosure function"},
|
|
{0x04679800, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4120: SAS cable VPD cannot be read"},
|
|
{0x046E0000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFF4: Command to logical unit failed"},
|
|
{0x05240000, 1, 0,
|
|
"Illegal request, invalid request type or request packet"},
|
|
{0x05250000, 0, 0,
|
|
"Illegal request, invalid resource handle"},
|
|
{0x05258000, 0, 0,
|
|
"Illegal request, commands not allowed to this device"},
|
|
{0x05258100, 0, 0,
|
|
"Illegal request, command not allowed to a secondary adapter"},
|
|
{0x05258200, 0, 0,
|
|
"Illegal request, command not allowed to a non-optimized resource"},
|
|
{0x05260000, 0, 0,
|
|
"Illegal request, invalid field in parameter list"},
|
|
{0x05260100, 0, 0,
|
|
"Illegal request, parameter not supported"},
|
|
{0x05260200, 0, 0,
|
|
"Illegal request, parameter value invalid"},
|
|
{0x052C0000, 0, 0,
|
|
"Illegal request, command sequence error"},
|
|
{0x052C8000, 1, 0,
|
|
"Illegal request, dual adapter support not enabled"},
|
|
{0x052C8100, 1, 0,
|
|
"Illegal request, another cable connector was physically disabled"},
|
|
{0x054E8000, 1, 0,
|
|
"Illegal request, inconsistent group id/group count"},
|
|
{0x06040500, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9031: Array protection temporarily suspended, protection resuming"},
|
|
{0x06040600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9040: Array protection temporarily suspended, protection resuming"},
|
|
{0x060B0100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4080: IOA exceeded maximum operating temperature"},
|
|
{0x060B8000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4085: Service required"},
|
|
{0x060B8100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4086: SAS Adapter Hardware Configuration Error"},
|
|
{0x06288000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3140: Device bus not ready to ready transition"},
|
|
{0x06290000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFB: SCSI bus was reset"},
|
|
{0x06290500, 0, 0,
|
|
"FFFE: SCSI bus transition to single ended"},
|
|
{0x06290600, 0, 0,
|
|
"FFFE: SCSI bus transition to LVD"},
|
|
{0x06298000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"FFFB: SCSI bus was reset by another initiator"},
|
|
{0x063F0300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3029: A device replacement has occurred"},
|
|
{0x063F8300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4102: Device bus fabric performance degradation"},
|
|
{0x064C8000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9051: IOA cache data exists for a missing or failed device"},
|
|
{0x064C8100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9055: Auxiliary cache IOA contains cache data needed by the primary IOA"},
|
|
{0x06670100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9025: Disk unit is not supported at its physical location"},
|
|
{0x06670600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3020: IOA detected a SCSI bus configuration error"},
|
|
{0x06678000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"3150: SCSI bus configuration error"},
|
|
{0x06678100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9074: Asymmetric advanced function disk configuration"},
|
|
{0x06678300, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4040: Incomplete multipath connection between IOA and enclosure"},
|
|
{0x06678400, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4041: Incomplete multipath connection between enclosure and device"},
|
|
{0x06678500, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9075: Incomplete multipath connection between IOA and remote IOA"},
|
|
{0x06678600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9076: Configuration error, missing remote IOA"},
|
|
{0x06679100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4050: Enclosure does not support a required multipath function"},
|
|
{0x06679800, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4121: Configuration error, required cable is missing"},
|
|
{0x06679900, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4122: Cable is not plugged into the correct location on remote IOA"},
|
|
{0x06679A00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4123: Configuration error, invalid cable vital product data"},
|
|
{0x06679B00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4124: Configuration error, both cable ends are plugged into the same IOA"},
|
|
{0x06690000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4070: Logically bad block written on device"},
|
|
{0x06690200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9041: Array protection temporarily suspended"},
|
|
{0x06698200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9042: Corrupt array parity detected on specified device"},
|
|
{0x066B0200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9030: Array no longer protected due to missing or failed disk unit"},
|
|
{0x066B8000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9071: Link operational transition"},
|
|
{0x066B8100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9072: Link not operational transition"},
|
|
{0x066B8200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9032: Array exposed but still protected"},
|
|
{0x066B8300, 0, IPR_DEBUG_LOG_LEVEL,
|
|
"70DD: Device forced failed by disrupt device command"},
|
|
{0x066B9100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4061: Multipath redundancy level got better"},
|
|
{0x066B9200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"4060: Multipath redundancy level got worse"},
|
|
{0x06808100, 0, IPR_DEBUG_LOG_LEVEL,
|
|
"9083: Device raw mode enabled"},
|
|
{0x06808200, 0, IPR_DEBUG_LOG_LEVEL,
|
|
"9084: Device raw mode disabled"},
|
|
{0x07270000, 0, 0,
|
|
"Failure due to other device"},
|
|
{0x07278000, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9008: IOA does not support functions expected by devices"},
|
|
{0x07278100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9010: Cache data associated with attached devices cannot be found"},
|
|
{0x07278200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9011: Cache data belongs to devices other than those attached"},
|
|
{0x07278400, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9020: Array missing 2 or more devices with only 1 device present"},
|
|
{0x07278500, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9021: Array missing 2 or more devices with 2 or more devices present"},
|
|
{0x07278600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9022: Exposed array is missing a required device"},
|
|
{0x07278700, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9023: Array member(s) not at required physical locations"},
|
|
{0x07278800, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9024: Array not functional due to present hardware configuration"},
|
|
{0x07278900, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9026: Array not functional due to present hardware configuration"},
|
|
{0x07278A00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9027: Array is missing a device and parity is out of sync"},
|
|
{0x07278B00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9028: Maximum number of arrays already exist"},
|
|
{0x07278C00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9050: Required cache data cannot be located for a disk unit"},
|
|
{0x07278D00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9052: Cache data exists for a device that has been modified"},
|
|
{0x07278F00, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9054: IOA resources not available due to previous problems"},
|
|
{0x07279100, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9092: Disk unit requires initialization before use"},
|
|
{0x07279200, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9029: Incorrect hardware configuration change has been detected"},
|
|
{0x07279600, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9060: One or more disk pairs are missing from an array"},
|
|
{0x07279700, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9061: One or more disks are missing from an array"},
|
|
{0x07279800, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9062: One or more disks are missing from an array"},
|
|
{0x07279900, 0, IPR_DEFAULT_LOG_LEVEL,
|
|
"9063: Maximum number of functional arrays has been exceeded"},
|
|
{0x07279A00, 0, 0,
|
|
"Data protect, other volume set problem"},
|
|
{0x0B260000, 0, 0,
|
|
"Aborted command, invalid descriptor"},
|
|
{0x0B3F9000, 0, 0,
|
|
"Target operating conditions have changed, dual adapter takeover"},
|
|
{0x0B530200, 0, 0,
|
|
"Aborted command, medium removal prevented"},
|
|
{0x0B5A0000, 0, 0,
|
|
"Command terminated by host"},
|
|
{0x0B5B8000, 0, 0,
|
|
"Aborted command, command terminated by host"}
|
|
};
|
|
|
|
static const struct ipr_ses_table_entry ipr_ses_table[] = {
|
|
{ "2104-DL1 ", "XXXXXXXXXXXXXXXX", 80 },
|
|
{ "2104-TL1 ", "XXXXXXXXXXXXXXXX", 80 },
|
|
{ "HSBP07M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 7 slot */
|
|
{ "HSBP05M P U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Hidive 5 slot */
|
|
{ "HSBP05M S U2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* Bowtie */
|
|
{ "HSBP06E ASU2SCSI", "XXXXXXXXXXXXXXXX", 80 }, /* MartinFenning */
|
|
{ "2104-DU3 ", "XXXXXXXXXXXXXXXX", 160 },
|
|
{ "2104-TU3 ", "XXXXXXXXXXXXXXXX", 160 },
|
|
{ "HSBP04C RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
|
|
{ "HSBP06E RSU2SCSI", "XXXXXXX*XXXXXXXX", 160 },
|
|
{ "St V1S2 ", "XXXXXXXXXXXXXXXX", 160 },
|
|
{ "HSBPD4M PU3SCSI", "XXXXXXX*XXXXXXXX", 160 },
|
|
{ "VSBPD1H U3SCSI", "XXXXXXX*XXXXXXXX", 160 }
|
|
};
|
|
|
|
/*
|
|
* Function Prototypes
|
|
*/
|
|
static int ipr_reset_alert(struct ipr_cmnd *);
|
|
static void ipr_process_ccn(struct ipr_cmnd *);
|
|
static void ipr_process_error(struct ipr_cmnd *);
|
|
static void ipr_reset_ioa_job(struct ipr_cmnd *);
|
|
static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *,
|
|
enum ipr_shutdown_type);
|
|
|
|
#ifdef CONFIG_SCSI_IPR_TRACE
|
|
/**
|
|
* ipr_trc_hook - Add a trace entry to the driver trace
|
|
* @ipr_cmd: ipr command struct
|
|
* @type: trace type
|
|
* @add_data: additional data
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_trc_hook(struct ipr_cmnd *ipr_cmd,
|
|
u8 type, u32 add_data)
|
|
{
|
|
struct ipr_trace_entry *trace_entry;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
unsigned int trace_index;
|
|
|
|
trace_index = atomic_add_return(1, &ioa_cfg->trace_index) & IPR_TRACE_INDEX_MASK;
|
|
trace_entry = &ioa_cfg->trace[trace_index];
|
|
trace_entry->time = jiffies;
|
|
trace_entry->op_code = ipr_cmd->ioarcb.cmd_pkt.cdb[0];
|
|
trace_entry->type = type;
|
|
if (ipr_cmd->ioa_cfg->sis64)
|
|
trace_entry->ata_op_code = ipr_cmd->i.ata_ioadl.regs.command;
|
|
else
|
|
trace_entry->ata_op_code = ipr_cmd->ioarcb.u.add_data.u.regs.command;
|
|
trace_entry->cmd_index = ipr_cmd->cmd_index & 0xff;
|
|
trace_entry->res_handle = ipr_cmd->ioarcb.res_handle;
|
|
trace_entry->u.add_data = add_data;
|
|
wmb();
|
|
}
|
|
#else
|
|
#define ipr_trc_hook(ipr_cmd, type, add_data) do { } while (0)
|
|
#endif
|
|
|
|
/**
|
|
* ipr_lock_and_done - Acquire lock and complete command
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_lock_and_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
unsigned long lock_flags;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ipr_cmd->done(ipr_cmd);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_reinit_ipr_cmnd - Re-initialize an IPR Cmnd block for reuse
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_reinit_ipr_cmnd(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
|
|
struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
|
|
dma_addr_t dma_addr = ipr_cmd->dma_addr;
|
|
int hrrq_id;
|
|
|
|
hrrq_id = ioarcb->cmd_pkt.hrrq_id;
|
|
memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
|
|
ioarcb->cmd_pkt.hrrq_id = hrrq_id;
|
|
ioarcb->data_transfer_length = 0;
|
|
ioarcb->read_data_transfer_length = 0;
|
|
ioarcb->ioadl_len = 0;
|
|
ioarcb->read_ioadl_len = 0;
|
|
|
|
if (ipr_cmd->ioa_cfg->sis64) {
|
|
ioarcb->u.sis64_addr_data.data_ioadl_addr =
|
|
cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
|
|
ioasa64->u.gata.status = 0;
|
|
} else {
|
|
ioarcb->write_ioadl_addr =
|
|
cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
|
|
ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
|
|
ioasa->u.gata.status = 0;
|
|
}
|
|
|
|
ioasa->hdr.ioasc = 0;
|
|
ioasa->hdr.residual_data_len = 0;
|
|
ipr_cmd->scsi_cmd = NULL;
|
|
ipr_cmd->qc = NULL;
|
|
ipr_cmd->sense_buffer[0] = 0;
|
|
ipr_cmd->dma_use_sg = 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_init_ipr_cmnd - Initialize an IPR Cmnd block
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_init_ipr_cmnd(struct ipr_cmnd *ipr_cmd,
|
|
void (*fast_done) (struct ipr_cmnd *))
|
|
{
|
|
ipr_reinit_ipr_cmnd(ipr_cmd);
|
|
ipr_cmd->u.scratch = 0;
|
|
ipr_cmd->sibling = NULL;
|
|
ipr_cmd->eh_comp = NULL;
|
|
ipr_cmd->fast_done = fast_done;
|
|
timer_setup(&ipr_cmd->timer, NULL, 0);
|
|
}
|
|
|
|
/**
|
|
* __ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* pointer to ipr command struct
|
|
**/
|
|
static
|
|
struct ipr_cmnd *__ipr_get_free_ipr_cmnd(struct ipr_hrr_queue *hrrq)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = NULL;
|
|
|
|
if (likely(!list_empty(&hrrq->hrrq_free_q))) {
|
|
ipr_cmd = list_entry(hrrq->hrrq_free_q.next,
|
|
struct ipr_cmnd, queue);
|
|
list_del(&ipr_cmd->queue);
|
|
}
|
|
|
|
|
|
return ipr_cmd;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_free_ipr_cmnd - Get a free IPR Cmnd block and initialize it
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* pointer to ipr command struct
|
|
**/
|
|
static
|
|
struct ipr_cmnd *ipr_get_free_ipr_cmnd(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd =
|
|
__ipr_get_free_ipr_cmnd(&ioa_cfg->hrrq[IPR_INIT_HRRQ]);
|
|
ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
|
|
return ipr_cmd;
|
|
}
|
|
|
|
/**
|
|
* ipr_mask_and_clear_interrupts - Mask all and clear specified interrupts
|
|
* @ioa_cfg: ioa config struct
|
|
* @clr_ints: interrupts to clear
|
|
*
|
|
* This function masks all interrupts on the adapter, then clears the
|
|
* interrupts specified in the mask
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_mask_and_clear_interrupts(struct ipr_ioa_cfg *ioa_cfg,
|
|
u32 clr_ints)
|
|
{
|
|
volatile u32 int_reg;
|
|
int i;
|
|
|
|
/* Stop new interrupts */
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].allow_interrupts = 0;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
|
|
/* Set interrupt mask to stop all new interrupts */
|
|
if (ioa_cfg->sis64)
|
|
writeq(~0, ioa_cfg->regs.set_interrupt_mask_reg);
|
|
else
|
|
writel(~0, ioa_cfg->regs.set_interrupt_mask_reg);
|
|
|
|
/* Clear any pending interrupts */
|
|
if (ioa_cfg->sis64)
|
|
writel(~0, ioa_cfg->regs.clr_interrupt_reg);
|
|
writel(clr_ints, ioa_cfg->regs.clr_interrupt_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
}
|
|
|
|
/**
|
|
* ipr_save_pcix_cmd_reg - Save PCI-X command register
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / -EIO on failure
|
|
**/
|
|
static int ipr_save_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
|
|
|
|
if (pcix_cmd_reg == 0)
|
|
return 0;
|
|
|
|
if (pci_read_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
|
|
&ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
|
|
dev_err(&ioa_cfg->pdev->dev, "Failed to save PCI-X command register\n");
|
|
return -EIO;
|
|
}
|
|
|
|
ioa_cfg->saved_pcix_cmd_reg |= PCI_X_CMD_DPERR_E | PCI_X_CMD_ERO;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_set_pcix_cmd_reg - Setup PCI-X command register
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / -EIO on failure
|
|
**/
|
|
static int ipr_set_pcix_cmd_reg(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int pcix_cmd_reg = pci_find_capability(ioa_cfg->pdev, PCI_CAP_ID_PCIX);
|
|
|
|
if (pcix_cmd_reg) {
|
|
if (pci_write_config_word(ioa_cfg->pdev, pcix_cmd_reg + PCI_X_CMD,
|
|
ioa_cfg->saved_pcix_cmd_reg) != PCIBIOS_SUCCESSFUL) {
|
|
dev_err(&ioa_cfg->pdev->dev, "Failed to setup PCI-X command register\n");
|
|
return -EIO;
|
|
}
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* __ipr_sata_eh_done - done function for aborted SATA commands
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked for ops generated to SATA
|
|
* devices which are being aborted.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void __ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ata_queued_cmd *qc = ipr_cmd->qc;
|
|
struct ipr_sata_port *sata_port = qc->ap->private_data;
|
|
|
|
qc->err_mask |= AC_ERR_OTHER;
|
|
sata_port->ioasa.status |= ATA_BUSY;
|
|
ata_qc_complete(qc);
|
|
if (ipr_cmd->eh_comp)
|
|
complete(ipr_cmd->eh_comp);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_sata_eh_done - done function for aborted SATA commands
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked for ops generated to SATA
|
|
* devices which are being aborted.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_sata_eh_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
|
|
unsigned long hrrq_flags;
|
|
|
|
spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
|
|
__ipr_sata_eh_done(ipr_cmd);
|
|
spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
|
|
}
|
|
|
|
/**
|
|
* __ipr_scsi_eh_done - mid-layer done function for aborted ops
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked by the interrupt handler for
|
|
* ops generated by the SCSI mid-layer which are being aborted.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void __ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
|
|
scsi_cmd->result |= (DID_ERROR << 16);
|
|
|
|
scsi_dma_unmap(ipr_cmd->scsi_cmd);
|
|
scsi_cmd->scsi_done(scsi_cmd);
|
|
if (ipr_cmd->eh_comp)
|
|
complete(ipr_cmd->eh_comp);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_scsi_eh_done - mid-layer done function for aborted ops
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked by the interrupt handler for
|
|
* ops generated by the SCSI mid-layer which are being aborted.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_scsi_eh_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
unsigned long hrrq_flags;
|
|
struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
|
|
|
|
spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
|
|
__ipr_scsi_eh_done(ipr_cmd);
|
|
spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_fail_all_ops - Fails all outstanding ops.
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* This function fails all outstanding ops.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_fail_all_ops(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd, *temp;
|
|
struct ipr_hrr_queue *hrrq;
|
|
|
|
ENTER;
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
list_for_each_entry_safe(ipr_cmd,
|
|
temp, &hrrq->hrrq_pending_q, queue) {
|
|
list_del(&ipr_cmd->queue);
|
|
|
|
ipr_cmd->s.ioasa.hdr.ioasc =
|
|
cpu_to_be32(IPR_IOASC_IOA_WAS_RESET);
|
|
ipr_cmd->s.ioasa.hdr.ilid =
|
|
cpu_to_be32(IPR_DRIVER_ILID);
|
|
|
|
if (ipr_cmd->scsi_cmd)
|
|
ipr_cmd->done = __ipr_scsi_eh_done;
|
|
else if (ipr_cmd->qc)
|
|
ipr_cmd->done = __ipr_sata_eh_done;
|
|
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH,
|
|
IPR_IOASC_IOA_WAS_RESET);
|
|
del_timer(&ipr_cmd->timer);
|
|
ipr_cmd->done(ipr_cmd);
|
|
}
|
|
spin_unlock(&hrrq->_lock);
|
|
}
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_send_command - Send driver initiated requests.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a command to the adapter using the correct write call.
|
|
* In the case of sis64, calculate the ioarcb size required. Then or in the
|
|
* appropriate bits.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_send_command(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
dma_addr_t send_dma_addr = ipr_cmd->dma_addr;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
/* The default size is 256 bytes */
|
|
send_dma_addr |= 0x1;
|
|
|
|
/* If the number of ioadls * size of ioadl > 128 bytes,
|
|
then use a 512 byte ioarcb */
|
|
if (ipr_cmd->dma_use_sg * sizeof(struct ipr_ioadl64_desc) > 128 )
|
|
send_dma_addr |= 0x4;
|
|
writeq(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
|
|
} else
|
|
writel(send_dma_addr, ioa_cfg->regs.ioarrin_reg);
|
|
}
|
|
|
|
/**
|
|
* ipr_do_req - Send driver initiated requests.
|
|
* @ipr_cmd: ipr command struct
|
|
* @done: done function
|
|
* @timeout_func: timeout function
|
|
* @timeout: timeout value
|
|
*
|
|
* This function sends the specified command to the adapter with the
|
|
* timeout given. The done function is invoked on command completion.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_do_req(struct ipr_cmnd *ipr_cmd,
|
|
void (*done) (struct ipr_cmnd *),
|
|
void (*timeout_func) (struct timer_list *), u32 timeout)
|
|
{
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
|
|
ipr_cmd->done = done;
|
|
|
|
ipr_cmd->timer.expires = jiffies + timeout;
|
|
ipr_cmd->timer.function = timeout_func;
|
|
|
|
add_timer(&ipr_cmd->timer);
|
|
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_START, 0);
|
|
|
|
ipr_send_command(ipr_cmd);
|
|
}
|
|
|
|
/**
|
|
* ipr_internal_cmd_done - Op done function for an internally generated op.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is the op done function for an internally generated,
|
|
* blocking op. It simply wakes the sleeping thread.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_internal_cmd_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
if (ipr_cmd->sibling)
|
|
ipr_cmd->sibling = NULL;
|
|
else
|
|
complete(&ipr_cmd->completion);
|
|
}
|
|
|
|
/**
|
|
* ipr_init_ioadl - initialize the ioadl for the correct SIS type
|
|
* @ipr_cmd: ipr command struct
|
|
* @dma_addr: dma address
|
|
* @len: transfer length
|
|
* @flags: ioadl flag value
|
|
*
|
|
* This function initializes an ioadl in the case where there is only a single
|
|
* descriptor.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_init_ioadl(struct ipr_cmnd *ipr_cmd, dma_addr_t dma_addr,
|
|
u32 len, int flags)
|
|
{
|
|
struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
|
|
struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
|
|
|
|
ipr_cmd->dma_use_sg = 1;
|
|
|
|
if (ipr_cmd->ioa_cfg->sis64) {
|
|
ioadl64->flags = cpu_to_be32(flags);
|
|
ioadl64->data_len = cpu_to_be32(len);
|
|
ioadl64->address = cpu_to_be64(dma_addr);
|
|
|
|
ipr_cmd->ioarcb.ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl64_desc));
|
|
ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
|
|
} else {
|
|
ioadl->flags_and_data_len = cpu_to_be32(flags | len);
|
|
ioadl->address = cpu_to_be32(dma_addr);
|
|
|
|
if (flags == IPR_IOADL_FLAGS_READ_LAST) {
|
|
ipr_cmd->ioarcb.read_ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc));
|
|
ipr_cmd->ioarcb.read_data_transfer_length = cpu_to_be32(len);
|
|
} else {
|
|
ipr_cmd->ioarcb.ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc));
|
|
ipr_cmd->ioarcb.data_transfer_length = cpu_to_be32(len);
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_send_blocking_cmd - Send command and sleep on its completion.
|
|
* @ipr_cmd: ipr command struct
|
|
* @timeout_func: function to invoke if command times out
|
|
* @timeout: timeout
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_send_blocking_cmd(struct ipr_cmnd *ipr_cmd,
|
|
void (*timeout_func) (struct timer_list *),
|
|
u32 timeout)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
init_completion(&ipr_cmd->completion);
|
|
ipr_do_req(ipr_cmd, ipr_internal_cmd_done, timeout_func, timeout);
|
|
|
|
spin_unlock_irq(ioa_cfg->host->host_lock);
|
|
wait_for_completion(&ipr_cmd->completion);
|
|
spin_lock_irq(ioa_cfg->host->host_lock);
|
|
}
|
|
|
|
static int ipr_get_hrrq_index(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
unsigned int hrrq;
|
|
|
|
if (ioa_cfg->hrrq_num == 1)
|
|
hrrq = 0;
|
|
else {
|
|
hrrq = atomic_add_return(1, &ioa_cfg->hrrq_index);
|
|
hrrq = (hrrq % (ioa_cfg->hrrq_num - 1)) + 1;
|
|
}
|
|
return hrrq;
|
|
}
|
|
|
|
/**
|
|
* ipr_send_hcam - Send an HCAM to the adapter.
|
|
* @ioa_cfg: ioa config struct
|
|
* @type: HCAM type
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* This function will send a Host Controlled Async command to the adapter.
|
|
* If HCAMs are currently not allowed to be issued to the adapter, it will
|
|
* place the hostrcb on the free queue.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_send_hcam(struct ipr_ioa_cfg *ioa_cfg, u8 type,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioarcb *ioarcb;
|
|
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
|
|
ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_pending_q);
|
|
|
|
ipr_cmd->u.hostrcb = hostrcb;
|
|
ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_HCAM;
|
|
ioarcb->cmd_pkt.cdb[0] = IPR_HOST_CONTROLLED_ASYNC;
|
|
ioarcb->cmd_pkt.cdb[1] = type;
|
|
ioarcb->cmd_pkt.cdb[7] = (sizeof(hostrcb->hcam) >> 8) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[8] = sizeof(hostrcb->hcam) & 0xff;
|
|
|
|
ipr_init_ioadl(ipr_cmd, hostrcb->hostrcb_dma,
|
|
sizeof(hostrcb->hcam), IPR_IOADL_FLAGS_READ_LAST);
|
|
|
|
if (type == IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE)
|
|
ipr_cmd->done = ipr_process_ccn;
|
|
else
|
|
ipr_cmd->done = ipr_process_error;
|
|
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_IOA_RES_ADDR);
|
|
|
|
ipr_send_command(ipr_cmd);
|
|
} else {
|
|
list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_update_ata_class - Update the ata class in the resource entry
|
|
* @res: resource entry struct
|
|
* @proto: cfgte device bus protocol value
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_update_ata_class(struct ipr_resource_entry *res, unsigned int proto)
|
|
{
|
|
switch (proto) {
|
|
case IPR_PROTO_SATA:
|
|
case IPR_PROTO_SAS_STP:
|
|
res->ata_class = ATA_DEV_ATA;
|
|
break;
|
|
case IPR_PROTO_SATA_ATAPI:
|
|
case IPR_PROTO_SAS_STP_ATAPI:
|
|
res->ata_class = ATA_DEV_ATAPI;
|
|
break;
|
|
default:
|
|
res->ata_class = ATA_DEV_UNKNOWN;
|
|
break;
|
|
};
|
|
}
|
|
|
|
/**
|
|
* ipr_init_res_entry - Initialize a resource entry struct.
|
|
* @res: resource entry struct
|
|
* @cfgtew: config table entry wrapper struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_init_res_entry(struct ipr_resource_entry *res,
|
|
struct ipr_config_table_entry_wrapper *cfgtew)
|
|
{
|
|
int found = 0;
|
|
unsigned int proto;
|
|
struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
|
|
struct ipr_resource_entry *gscsi_res = NULL;
|
|
|
|
res->needs_sync_complete = 0;
|
|
res->in_erp = 0;
|
|
res->add_to_ml = 0;
|
|
res->del_from_ml = 0;
|
|
res->resetting_device = 0;
|
|
res->reset_occurred = 0;
|
|
res->sdev = NULL;
|
|
res->sata_port = NULL;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
proto = cfgtew->u.cfgte64->proto;
|
|
res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
|
|
res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
|
|
res->qmodel = IPR_QUEUEING_MODEL64(res);
|
|
res->type = cfgtew->u.cfgte64->res_type;
|
|
|
|
memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
|
|
sizeof(res->res_path));
|
|
|
|
res->bus = 0;
|
|
memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
|
|
sizeof(res->dev_lun.scsi_lun));
|
|
res->lun = scsilun_to_int(&res->dev_lun);
|
|
|
|
if (res->type == IPR_RES_TYPE_GENERIC_SCSI) {
|
|
list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue) {
|
|
if (gscsi_res->dev_id == cfgtew->u.cfgte64->dev_id) {
|
|
found = 1;
|
|
res->target = gscsi_res->target;
|
|
break;
|
|
}
|
|
}
|
|
if (!found) {
|
|
res->target = find_first_zero_bit(ioa_cfg->target_ids,
|
|
ioa_cfg->max_devs_supported);
|
|
set_bit(res->target, ioa_cfg->target_ids);
|
|
}
|
|
} else if (res->type == IPR_RES_TYPE_IOAFP) {
|
|
res->bus = IPR_IOAFP_VIRTUAL_BUS;
|
|
res->target = 0;
|
|
} else if (res->type == IPR_RES_TYPE_ARRAY) {
|
|
res->bus = IPR_ARRAY_VIRTUAL_BUS;
|
|
res->target = find_first_zero_bit(ioa_cfg->array_ids,
|
|
ioa_cfg->max_devs_supported);
|
|
set_bit(res->target, ioa_cfg->array_ids);
|
|
} else if (res->type == IPR_RES_TYPE_VOLUME_SET) {
|
|
res->bus = IPR_VSET_VIRTUAL_BUS;
|
|
res->target = find_first_zero_bit(ioa_cfg->vset_ids,
|
|
ioa_cfg->max_devs_supported);
|
|
set_bit(res->target, ioa_cfg->vset_ids);
|
|
} else {
|
|
res->target = find_first_zero_bit(ioa_cfg->target_ids,
|
|
ioa_cfg->max_devs_supported);
|
|
set_bit(res->target, ioa_cfg->target_ids);
|
|
}
|
|
} else {
|
|
proto = cfgtew->u.cfgte->proto;
|
|
res->qmodel = IPR_QUEUEING_MODEL(res);
|
|
res->flags = cfgtew->u.cfgte->flags;
|
|
if (res->flags & IPR_IS_IOA_RESOURCE)
|
|
res->type = IPR_RES_TYPE_IOAFP;
|
|
else
|
|
res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
|
|
|
|
res->bus = cfgtew->u.cfgte->res_addr.bus;
|
|
res->target = cfgtew->u.cfgte->res_addr.target;
|
|
res->lun = cfgtew->u.cfgte->res_addr.lun;
|
|
res->lun_wwn = get_unaligned_be64(cfgtew->u.cfgte->lun_wwn);
|
|
}
|
|
|
|
ipr_update_ata_class(res, proto);
|
|
}
|
|
|
|
/**
|
|
* ipr_is_same_device - Determine if two devices are the same.
|
|
* @res: resource entry struct
|
|
* @cfgtew: config table entry wrapper struct
|
|
*
|
|
* Return value:
|
|
* 1 if the devices are the same / 0 otherwise
|
|
**/
|
|
static int ipr_is_same_device(struct ipr_resource_entry *res,
|
|
struct ipr_config_table_entry_wrapper *cfgtew)
|
|
{
|
|
if (res->ioa_cfg->sis64) {
|
|
if (!memcmp(&res->dev_id, &cfgtew->u.cfgte64->dev_id,
|
|
sizeof(cfgtew->u.cfgte64->dev_id)) &&
|
|
!memcmp(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
|
|
sizeof(cfgtew->u.cfgte64->lun))) {
|
|
return 1;
|
|
}
|
|
} else {
|
|
if (res->bus == cfgtew->u.cfgte->res_addr.bus &&
|
|
res->target == cfgtew->u.cfgte->res_addr.target &&
|
|
res->lun == cfgtew->u.cfgte->res_addr.lun)
|
|
return 1;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* __ipr_format_res_path - Format the resource path for printing.
|
|
* @res_path: resource path
|
|
* @buf: buffer
|
|
* @len: length of buffer provided
|
|
*
|
|
* Return value:
|
|
* pointer to buffer
|
|
**/
|
|
static char *__ipr_format_res_path(u8 *res_path, char *buffer, int len)
|
|
{
|
|
int i;
|
|
char *p = buffer;
|
|
|
|
*p = '\0';
|
|
p += snprintf(p, buffer + len - p, "%02X", res_path[0]);
|
|
for (i = 1; res_path[i] != 0xff && ((i * 3) < len); i++)
|
|
p += snprintf(p, buffer + len - p, "-%02X", res_path[i]);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* ipr_format_res_path - Format the resource path for printing.
|
|
* @ioa_cfg: ioa config struct
|
|
* @res_path: resource path
|
|
* @buf: buffer
|
|
* @len: length of buffer provided
|
|
*
|
|
* Return value:
|
|
* pointer to buffer
|
|
**/
|
|
static char *ipr_format_res_path(struct ipr_ioa_cfg *ioa_cfg,
|
|
u8 *res_path, char *buffer, int len)
|
|
{
|
|
char *p = buffer;
|
|
|
|
*p = '\0';
|
|
p += snprintf(p, buffer + len - p, "%d/", ioa_cfg->host->host_no);
|
|
__ipr_format_res_path(res_path, p, len - (buffer - p));
|
|
return buffer;
|
|
}
|
|
|
|
/**
|
|
* ipr_update_res_entry - Update the resource entry.
|
|
* @res: resource entry struct
|
|
* @cfgtew: config table entry wrapper struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_update_res_entry(struct ipr_resource_entry *res,
|
|
struct ipr_config_table_entry_wrapper *cfgtew)
|
|
{
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
unsigned int proto;
|
|
int new_path = 0;
|
|
|
|
if (res->ioa_cfg->sis64) {
|
|
res->flags = be16_to_cpu(cfgtew->u.cfgte64->flags);
|
|
res->res_flags = be16_to_cpu(cfgtew->u.cfgte64->res_flags);
|
|
res->type = cfgtew->u.cfgte64->res_type;
|
|
|
|
memcpy(&res->std_inq_data, &cfgtew->u.cfgte64->std_inq_data,
|
|
sizeof(struct ipr_std_inq_data));
|
|
|
|
res->qmodel = IPR_QUEUEING_MODEL64(res);
|
|
proto = cfgtew->u.cfgte64->proto;
|
|
res->res_handle = cfgtew->u.cfgte64->res_handle;
|
|
res->dev_id = cfgtew->u.cfgte64->dev_id;
|
|
|
|
memcpy(&res->dev_lun.scsi_lun, &cfgtew->u.cfgte64->lun,
|
|
sizeof(res->dev_lun.scsi_lun));
|
|
|
|
if (memcmp(res->res_path, &cfgtew->u.cfgte64->res_path,
|
|
sizeof(res->res_path))) {
|
|
memcpy(res->res_path, &cfgtew->u.cfgte64->res_path,
|
|
sizeof(res->res_path));
|
|
new_path = 1;
|
|
}
|
|
|
|
if (res->sdev && new_path)
|
|
sdev_printk(KERN_INFO, res->sdev, "Resource path: %s\n",
|
|
ipr_format_res_path(res->ioa_cfg,
|
|
res->res_path, buffer, sizeof(buffer)));
|
|
} else {
|
|
res->flags = cfgtew->u.cfgte->flags;
|
|
if (res->flags & IPR_IS_IOA_RESOURCE)
|
|
res->type = IPR_RES_TYPE_IOAFP;
|
|
else
|
|
res->type = cfgtew->u.cfgte->rsvd_subtype & 0x0f;
|
|
|
|
memcpy(&res->std_inq_data, &cfgtew->u.cfgte->std_inq_data,
|
|
sizeof(struct ipr_std_inq_data));
|
|
|
|
res->qmodel = IPR_QUEUEING_MODEL(res);
|
|
proto = cfgtew->u.cfgte->proto;
|
|
res->res_handle = cfgtew->u.cfgte->res_handle;
|
|
}
|
|
|
|
ipr_update_ata_class(res, proto);
|
|
}
|
|
|
|
/**
|
|
* ipr_clear_res_target - Clear the bit in the bit map representing the target
|
|
* for the resource.
|
|
* @res: resource entry struct
|
|
* @cfgtew: config table entry wrapper struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_clear_res_target(struct ipr_resource_entry *res)
|
|
{
|
|
struct ipr_resource_entry *gscsi_res = NULL;
|
|
struct ipr_ioa_cfg *ioa_cfg = res->ioa_cfg;
|
|
|
|
if (!ioa_cfg->sis64)
|
|
return;
|
|
|
|
if (res->bus == IPR_ARRAY_VIRTUAL_BUS)
|
|
clear_bit(res->target, ioa_cfg->array_ids);
|
|
else if (res->bus == IPR_VSET_VIRTUAL_BUS)
|
|
clear_bit(res->target, ioa_cfg->vset_ids);
|
|
else if (res->bus == 0 && res->type == IPR_RES_TYPE_GENERIC_SCSI) {
|
|
list_for_each_entry(gscsi_res, &ioa_cfg->used_res_q, queue)
|
|
if (gscsi_res->dev_id == res->dev_id && gscsi_res != res)
|
|
return;
|
|
clear_bit(res->target, ioa_cfg->target_ids);
|
|
|
|
} else if (res->bus == 0)
|
|
clear_bit(res->target, ioa_cfg->target_ids);
|
|
}
|
|
|
|
/**
|
|
* ipr_handle_config_change - Handle a config change from the adapter
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_handle_config_change(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_resource_entry *res = NULL;
|
|
struct ipr_config_table_entry_wrapper cfgtew;
|
|
__be32 cc_res_handle;
|
|
|
|
u32 is_ndn = 1;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
cfgtew.u.cfgte64 = &hostrcb->hcam.u.ccn.u.cfgte64;
|
|
cc_res_handle = cfgtew.u.cfgte64->res_handle;
|
|
} else {
|
|
cfgtew.u.cfgte = &hostrcb->hcam.u.ccn.u.cfgte;
|
|
cc_res_handle = cfgtew.u.cfgte->res_handle;
|
|
}
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (res->res_handle == cc_res_handle) {
|
|
is_ndn = 0;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (is_ndn) {
|
|
if (list_empty(&ioa_cfg->free_res_q)) {
|
|
ipr_send_hcam(ioa_cfg,
|
|
IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
|
|
hostrcb);
|
|
return;
|
|
}
|
|
|
|
res = list_entry(ioa_cfg->free_res_q.next,
|
|
struct ipr_resource_entry, queue);
|
|
|
|
list_del(&res->queue);
|
|
ipr_init_res_entry(res, &cfgtew);
|
|
list_add_tail(&res->queue, &ioa_cfg->used_res_q);
|
|
}
|
|
|
|
ipr_update_res_entry(res, &cfgtew);
|
|
|
|
if (hostrcb->hcam.notify_type == IPR_HOST_RCB_NOTIF_TYPE_REM_ENTRY) {
|
|
if (res->sdev) {
|
|
res->del_from_ml = 1;
|
|
res->res_handle = IPR_INVALID_RES_HANDLE;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
} else {
|
|
ipr_clear_res_target(res);
|
|
list_move_tail(&res->queue, &ioa_cfg->free_res_q);
|
|
}
|
|
} else if (!res->sdev || res->del_from_ml) {
|
|
res->add_to_ml = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
}
|
|
|
|
ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
|
|
}
|
|
|
|
/**
|
|
* ipr_process_ccn - Op done function for a CCN.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is the op done function for a configuration
|
|
* change notification host controlled async from the adapter.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_process_ccn(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
list_del_init(&hostrcb->queue);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
|
|
if (ioasc) {
|
|
if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
|
|
ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST)
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Host RCB failed with IOASC: 0x%08X\n", ioasc);
|
|
|
|
ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE, hostrcb);
|
|
} else {
|
|
ipr_handle_config_change(ioa_cfg, hostrcb);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* strip_and_pad_whitespace - Strip and pad trailing whitespace.
|
|
* @i: index into buffer
|
|
* @buf: string to modify
|
|
*
|
|
* This function will strip all trailing whitespace, pad the end
|
|
* of the string with a single space, and NULL terminate the string.
|
|
*
|
|
* Return value:
|
|
* new length of string
|
|
**/
|
|
static int strip_and_pad_whitespace(int i, char *buf)
|
|
{
|
|
while (i && buf[i] == ' ')
|
|
i--;
|
|
buf[i+1] = ' ';
|
|
buf[i+2] = '\0';
|
|
return i + 2;
|
|
}
|
|
|
|
/**
|
|
* ipr_log_vpd_compact - Log the passed extended VPD compactly.
|
|
* @prefix: string to print at start of printk
|
|
* @hostrcb: hostrcb pointer
|
|
* @vpd: vendor/product id/sn struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
|
|
struct ipr_vpd *vpd)
|
|
{
|
|
char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN + IPR_SERIAL_NUM_LEN + 3];
|
|
int i = 0;
|
|
|
|
memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
|
|
i = strip_and_pad_whitespace(IPR_VENDOR_ID_LEN - 1, buffer);
|
|
|
|
memcpy(&buffer[i], vpd->vpids.product_id, IPR_PROD_ID_LEN);
|
|
i = strip_and_pad_whitespace(i + IPR_PROD_ID_LEN - 1, buffer);
|
|
|
|
memcpy(&buffer[i], vpd->sn, IPR_SERIAL_NUM_LEN);
|
|
buffer[IPR_SERIAL_NUM_LEN + i] = '\0';
|
|
|
|
ipr_hcam_err(hostrcb, "%s VPID/SN: %s\n", prefix, buffer);
|
|
}
|
|
|
|
/**
|
|
* ipr_log_vpd - Log the passed VPD to the error log.
|
|
* @vpd: vendor/product id/sn struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_vpd(struct ipr_vpd *vpd)
|
|
{
|
|
char buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN
|
|
+ IPR_SERIAL_NUM_LEN];
|
|
|
|
memcpy(buffer, vpd->vpids.vendor_id, IPR_VENDOR_ID_LEN);
|
|
memcpy(buffer + IPR_VENDOR_ID_LEN, vpd->vpids.product_id,
|
|
IPR_PROD_ID_LEN);
|
|
buffer[IPR_VENDOR_ID_LEN + IPR_PROD_ID_LEN] = '\0';
|
|
ipr_err("Vendor/Product ID: %s\n", buffer);
|
|
|
|
memcpy(buffer, vpd->sn, IPR_SERIAL_NUM_LEN);
|
|
buffer[IPR_SERIAL_NUM_LEN] = '\0';
|
|
ipr_err(" Serial Number: %s\n", buffer);
|
|
}
|
|
|
|
/**
|
|
* ipr_log_ext_vpd_compact - Log the passed extended VPD compactly.
|
|
* @prefix: string to print at start of printk
|
|
* @hostrcb: hostrcb pointer
|
|
* @vpd: vendor/product id/sn/wwn struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_ext_vpd_compact(char *prefix, struct ipr_hostrcb *hostrcb,
|
|
struct ipr_ext_vpd *vpd)
|
|
{
|
|
ipr_log_vpd_compact(prefix, hostrcb, &vpd->vpd);
|
|
ipr_hcam_err(hostrcb, "%s WWN: %08X%08X\n", prefix,
|
|
be32_to_cpu(vpd->wwid[0]), be32_to_cpu(vpd->wwid[1]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_ext_vpd - Log the passed extended VPD to the error log.
|
|
* @vpd: vendor/product id/sn/wwn struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_ext_vpd(struct ipr_ext_vpd *vpd)
|
|
{
|
|
ipr_log_vpd(&vpd->vpd);
|
|
ipr_err(" WWN: %08X%08X\n", be32_to_cpu(vpd->wwid[0]),
|
|
be32_to_cpu(vpd->wwid[1]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_enhanced_cache_error - Log a cache error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_enhanced_cache_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_12_error *error;
|
|
|
|
if (ioa_cfg->sis64)
|
|
error = &hostrcb->hcam.u.error64.u.type_12_error;
|
|
else
|
|
error = &hostrcb->hcam.u.error.u.type_12_error;
|
|
|
|
ipr_err("-----Current Configuration-----\n");
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_ext_vpd(&error->ioa_vpd);
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_ext_vpd(&error->cfc_vpd);
|
|
|
|
ipr_err("-----Expected Configuration-----\n");
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_ext_vpd(&error->ioa_last_attached_to_cfc_vpd);
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_ext_vpd(&error->cfc_last_attached_to_ioa_vpd);
|
|
|
|
ipr_err("Additional IOA Data: %08X %08X %08X\n",
|
|
be32_to_cpu(error->ioa_data[0]),
|
|
be32_to_cpu(error->ioa_data[1]),
|
|
be32_to_cpu(error->ioa_data[2]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_cache_error - Log a cache error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_cache_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_02_error *error =
|
|
&hostrcb->hcam.u.error.u.type_02_error;
|
|
|
|
ipr_err("-----Current Configuration-----\n");
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_vpd(&error->ioa_vpd);
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_vpd(&error->cfc_vpd);
|
|
|
|
ipr_err("-----Expected Configuration-----\n");
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_vpd(&error->ioa_last_attached_to_cfc_vpd);
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_vpd(&error->cfc_last_attached_to_ioa_vpd);
|
|
|
|
ipr_err("Additional IOA Data: %08X %08X %08X\n",
|
|
be32_to_cpu(error->ioa_data[0]),
|
|
be32_to_cpu(error->ioa_data[1]),
|
|
be32_to_cpu(error->ioa_data[2]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_enhanced_config_error - Log a configuration error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_enhanced_config_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int errors_logged, i;
|
|
struct ipr_hostrcb_device_data_entry_enhanced *dev_entry;
|
|
struct ipr_hostrcb_type_13_error *error;
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_13_error;
|
|
errors_logged = be32_to_cpu(error->errors_logged);
|
|
|
|
ipr_err("Device Errors Detected/Logged: %d/%d\n",
|
|
be32_to_cpu(error->errors_detected), errors_logged);
|
|
|
|
dev_entry = error->dev;
|
|
|
|
for (i = 0; i < errors_logged; i++, dev_entry++) {
|
|
ipr_err_separator;
|
|
|
|
ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
|
|
ipr_log_ext_vpd(&dev_entry->vpd);
|
|
|
|
ipr_err("-----New Device Information-----\n");
|
|
ipr_log_ext_vpd(&dev_entry->new_vpd);
|
|
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
|
|
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_sis64_config_error - Log a device error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_sis64_config_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int errors_logged, i;
|
|
struct ipr_hostrcb64_device_data_entry_enhanced *dev_entry;
|
|
struct ipr_hostrcb_type_23_error *error;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
error = &hostrcb->hcam.u.error64.u.type_23_error;
|
|
errors_logged = be32_to_cpu(error->errors_logged);
|
|
|
|
ipr_err("Device Errors Detected/Logged: %d/%d\n",
|
|
be32_to_cpu(error->errors_detected), errors_logged);
|
|
|
|
dev_entry = error->dev;
|
|
|
|
for (i = 0; i < errors_logged; i++, dev_entry++) {
|
|
ipr_err_separator;
|
|
|
|
ipr_err("Device %d : %s", i + 1,
|
|
__ipr_format_res_path(dev_entry->res_path,
|
|
buffer, sizeof(buffer)));
|
|
ipr_log_ext_vpd(&dev_entry->vpd);
|
|
|
|
ipr_err("-----New Device Information-----\n");
|
|
ipr_log_ext_vpd(&dev_entry->new_vpd);
|
|
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_ext_vpd(&dev_entry->ioa_last_with_dev_vpd);
|
|
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_ext_vpd(&dev_entry->cfc_last_with_dev_vpd);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_config_error - Log a configuration error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_config_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int errors_logged, i;
|
|
struct ipr_hostrcb_device_data_entry *dev_entry;
|
|
struct ipr_hostrcb_type_03_error *error;
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_03_error;
|
|
errors_logged = be32_to_cpu(error->errors_logged);
|
|
|
|
ipr_err("Device Errors Detected/Logged: %d/%d\n",
|
|
be32_to_cpu(error->errors_detected), errors_logged);
|
|
|
|
dev_entry = error->dev;
|
|
|
|
for (i = 0; i < errors_logged; i++, dev_entry++) {
|
|
ipr_err_separator;
|
|
|
|
ipr_phys_res_err(ioa_cfg, dev_entry->dev_res_addr, "Device %d", i + 1);
|
|
ipr_log_vpd(&dev_entry->vpd);
|
|
|
|
ipr_err("-----New Device Information-----\n");
|
|
ipr_log_vpd(&dev_entry->new_vpd);
|
|
|
|
ipr_err("Cache Directory Card Information:\n");
|
|
ipr_log_vpd(&dev_entry->ioa_last_with_dev_vpd);
|
|
|
|
ipr_err("Adapter Card Information:\n");
|
|
ipr_log_vpd(&dev_entry->cfc_last_with_dev_vpd);
|
|
|
|
ipr_err("Additional IOA Data: %08X %08X %08X %08X %08X\n",
|
|
be32_to_cpu(dev_entry->ioa_data[0]),
|
|
be32_to_cpu(dev_entry->ioa_data[1]),
|
|
be32_to_cpu(dev_entry->ioa_data[2]),
|
|
be32_to_cpu(dev_entry->ioa_data[3]),
|
|
be32_to_cpu(dev_entry->ioa_data[4]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_enhanced_array_error - Log an array configuration error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_enhanced_array_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int i, num_entries;
|
|
struct ipr_hostrcb_type_14_error *error;
|
|
struct ipr_hostrcb_array_data_entry_enhanced *array_entry;
|
|
const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_14_error;
|
|
|
|
ipr_err_separator;
|
|
|
|
ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
|
|
error->protection_level,
|
|
ioa_cfg->host->host_no,
|
|
error->last_func_vset_res_addr.bus,
|
|
error->last_func_vset_res_addr.target,
|
|
error->last_func_vset_res_addr.lun);
|
|
|
|
ipr_err_separator;
|
|
|
|
array_entry = error->array_member;
|
|
num_entries = min_t(u32, be32_to_cpu(error->num_entries),
|
|
ARRAY_SIZE(error->array_member));
|
|
|
|
for (i = 0; i < num_entries; i++, array_entry++) {
|
|
if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
|
|
continue;
|
|
|
|
if (be32_to_cpu(error->exposed_mode_adn) == i)
|
|
ipr_err("Exposed Array Member %d:\n", i);
|
|
else
|
|
ipr_err("Array Member %d:\n", i);
|
|
|
|
ipr_log_ext_vpd(&array_entry->vpd);
|
|
ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
|
|
ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
|
|
"Expected Location");
|
|
|
|
ipr_err_separator;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_array_error - Log an array configuration error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_array_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int i;
|
|
struct ipr_hostrcb_type_04_error *error;
|
|
struct ipr_hostrcb_array_data_entry *array_entry;
|
|
const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_04_error;
|
|
|
|
ipr_err_separator;
|
|
|
|
ipr_err("RAID %s Array Configuration: %d:%d:%d:%d\n",
|
|
error->protection_level,
|
|
ioa_cfg->host->host_no,
|
|
error->last_func_vset_res_addr.bus,
|
|
error->last_func_vset_res_addr.target,
|
|
error->last_func_vset_res_addr.lun);
|
|
|
|
ipr_err_separator;
|
|
|
|
array_entry = error->array_member;
|
|
|
|
for (i = 0; i < 18; i++) {
|
|
if (!memcmp(array_entry->vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
|
|
continue;
|
|
|
|
if (be32_to_cpu(error->exposed_mode_adn) == i)
|
|
ipr_err("Exposed Array Member %d:\n", i);
|
|
else
|
|
ipr_err("Array Member %d:\n", i);
|
|
|
|
ipr_log_vpd(&array_entry->vpd);
|
|
|
|
ipr_phys_res_err(ioa_cfg, array_entry->dev_res_addr, "Current Location");
|
|
ipr_phys_res_err(ioa_cfg, array_entry->expected_dev_res_addr,
|
|
"Expected Location");
|
|
|
|
ipr_err_separator;
|
|
|
|
if (i == 9)
|
|
array_entry = error->array_member2;
|
|
else
|
|
array_entry++;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_hex_data - Log additional hex IOA error data.
|
|
* @ioa_cfg: ioa config struct
|
|
* @data: IOA error data
|
|
* @len: data length
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_hex_data(struct ipr_ioa_cfg *ioa_cfg, __be32 *data, int len)
|
|
{
|
|
int i;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
if (ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
|
|
len = min_t(int, len, IPR_DEFAULT_MAX_ERROR_DUMP);
|
|
|
|
for (i = 0; i < len / 4; i += 4) {
|
|
ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
|
|
be32_to_cpu(data[i]),
|
|
be32_to_cpu(data[i+1]),
|
|
be32_to_cpu(data[i+2]),
|
|
be32_to_cpu(data[i+3]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_enhanced_dual_ioa_error - Log an enhanced dual adapter error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_enhanced_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_17_error *error;
|
|
|
|
if (ioa_cfg->sis64)
|
|
error = &hostrcb->hcam.u.error64.u.type_17_error;
|
|
else
|
|
error = &hostrcb->hcam.u.error.u.type_17_error;
|
|
|
|
error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
|
|
strim(error->failure_reason);
|
|
|
|
ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
|
|
be32_to_cpu(hostrcb->hcam.u.error.prc));
|
|
ipr_log_ext_vpd_compact("Remote IOA", hostrcb, &error->vpd);
|
|
ipr_log_hex_data(ioa_cfg, error->data,
|
|
be32_to_cpu(hostrcb->hcam.length) -
|
|
(offsetof(struct ipr_hostrcb_error, u) +
|
|
offsetof(struct ipr_hostrcb_type_17_error, data)));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_dual_ioa_error - Log a dual adapter error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_dual_ioa_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_07_error *error;
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_07_error;
|
|
error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
|
|
strim(error->failure_reason);
|
|
|
|
ipr_hcam_err(hostrcb, "%s [PRC: %08X]\n", error->failure_reason,
|
|
be32_to_cpu(hostrcb->hcam.u.error.prc));
|
|
ipr_log_vpd_compact("Remote IOA", hostrcb, &error->vpd);
|
|
ipr_log_hex_data(ioa_cfg, error->data,
|
|
be32_to_cpu(hostrcb->hcam.length) -
|
|
(offsetof(struct ipr_hostrcb_error, u) +
|
|
offsetof(struct ipr_hostrcb_type_07_error, data)));
|
|
}
|
|
|
|
static const struct {
|
|
u8 active;
|
|
char *desc;
|
|
} path_active_desc[] = {
|
|
{ IPR_PATH_NO_INFO, "Path" },
|
|
{ IPR_PATH_ACTIVE, "Active path" },
|
|
{ IPR_PATH_NOT_ACTIVE, "Inactive path" }
|
|
};
|
|
|
|
static const struct {
|
|
u8 state;
|
|
char *desc;
|
|
} path_state_desc[] = {
|
|
{ IPR_PATH_STATE_NO_INFO, "has no path state information available" },
|
|
{ IPR_PATH_HEALTHY, "is healthy" },
|
|
{ IPR_PATH_DEGRADED, "is degraded" },
|
|
{ IPR_PATH_FAILED, "is failed" }
|
|
};
|
|
|
|
/**
|
|
* ipr_log_fabric_path - Log a fabric path error
|
|
* @hostrcb: hostrcb struct
|
|
* @fabric: fabric descriptor
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_fabric_path(struct ipr_hostrcb *hostrcb,
|
|
struct ipr_hostrcb_fabric_desc *fabric)
|
|
{
|
|
int i, j;
|
|
u8 path_state = fabric->path_state;
|
|
u8 active = path_state & IPR_PATH_ACTIVE_MASK;
|
|
u8 state = path_state & IPR_PATH_STATE_MASK;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
|
|
if (path_active_desc[i].active != active)
|
|
continue;
|
|
|
|
for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
|
|
if (path_state_desc[j].state != state)
|
|
continue;
|
|
|
|
if (fabric->cascaded_expander == 0xff && fabric->phy == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d\n",
|
|
path_active_desc[i].desc, path_state_desc[j].desc,
|
|
fabric->ioa_port);
|
|
} else if (fabric->cascaded_expander == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Phy=%d\n",
|
|
path_active_desc[i].desc, path_state_desc[j].desc,
|
|
fabric->ioa_port, fabric->phy);
|
|
} else if (fabric->phy == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d\n",
|
|
path_active_desc[i].desc, path_state_desc[j].desc,
|
|
fabric->ioa_port, fabric->cascaded_expander);
|
|
} else {
|
|
ipr_hcam_err(hostrcb, "%s %s: IOA Port=%d, Cascade=%d, Phy=%d\n",
|
|
path_active_desc[i].desc, path_state_desc[j].desc,
|
|
fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
ipr_err("Path state=%02X IOA Port=%d Cascade=%d Phy=%d\n", path_state,
|
|
fabric->ioa_port, fabric->cascaded_expander, fabric->phy);
|
|
}
|
|
|
|
/**
|
|
* ipr_log64_fabric_path - Log a fabric path error
|
|
* @hostrcb: hostrcb struct
|
|
* @fabric: fabric descriptor
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log64_fabric_path(struct ipr_hostrcb *hostrcb,
|
|
struct ipr_hostrcb64_fabric_desc *fabric)
|
|
{
|
|
int i, j;
|
|
u8 path_state = fabric->path_state;
|
|
u8 active = path_state & IPR_PATH_ACTIVE_MASK;
|
|
u8 state = path_state & IPR_PATH_STATE_MASK;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
for (i = 0; i < ARRAY_SIZE(path_active_desc); i++) {
|
|
if (path_active_desc[i].active != active)
|
|
continue;
|
|
|
|
for (j = 0; j < ARRAY_SIZE(path_state_desc); j++) {
|
|
if (path_state_desc[j].state != state)
|
|
continue;
|
|
|
|
ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s\n",
|
|
path_active_desc[i].desc, path_state_desc[j].desc,
|
|
ipr_format_res_path(hostrcb->ioa_cfg,
|
|
fabric->res_path,
|
|
buffer, sizeof(buffer)));
|
|
return;
|
|
}
|
|
}
|
|
|
|
ipr_err("Path state=%02X Resource Path=%s\n", path_state,
|
|
ipr_format_res_path(hostrcb->ioa_cfg, fabric->res_path,
|
|
buffer, sizeof(buffer)));
|
|
}
|
|
|
|
static const struct {
|
|
u8 type;
|
|
char *desc;
|
|
} path_type_desc[] = {
|
|
{ IPR_PATH_CFG_IOA_PORT, "IOA port" },
|
|
{ IPR_PATH_CFG_EXP_PORT, "Expander port" },
|
|
{ IPR_PATH_CFG_DEVICE_PORT, "Device port" },
|
|
{ IPR_PATH_CFG_DEVICE_LUN, "Device LUN" }
|
|
};
|
|
|
|
static const struct {
|
|
u8 status;
|
|
char *desc;
|
|
} path_status_desc[] = {
|
|
{ IPR_PATH_CFG_NO_PROB, "Functional" },
|
|
{ IPR_PATH_CFG_DEGRADED, "Degraded" },
|
|
{ IPR_PATH_CFG_FAILED, "Failed" },
|
|
{ IPR_PATH_CFG_SUSPECT, "Suspect" },
|
|
{ IPR_PATH_NOT_DETECTED, "Missing" },
|
|
{ IPR_PATH_INCORRECT_CONN, "Incorrectly connected" }
|
|
};
|
|
|
|
static const char *link_rate[] = {
|
|
"unknown",
|
|
"disabled",
|
|
"phy reset problem",
|
|
"spinup hold",
|
|
"port selector",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"1.5Gbps",
|
|
"3.0Gbps",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown",
|
|
"unknown"
|
|
};
|
|
|
|
/**
|
|
* ipr_log_path_elem - Log a fabric path element.
|
|
* @hostrcb: hostrcb struct
|
|
* @cfg: fabric path element struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_path_elem(struct ipr_hostrcb *hostrcb,
|
|
struct ipr_hostrcb_config_element *cfg)
|
|
{
|
|
int i, j;
|
|
u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
|
|
u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
|
|
|
|
if (type == IPR_PATH_CFG_NOT_EXIST)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
|
|
if (path_type_desc[i].type != type)
|
|
continue;
|
|
|
|
for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
|
|
if (path_status_desc[j].status != status)
|
|
continue;
|
|
|
|
if (type == IPR_PATH_CFG_IOA_PORT) {
|
|
ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, WWN=%08X%08X\n",
|
|
path_status_desc[j].desc, path_type_desc[i].desc,
|
|
cfg->phy, link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
} else {
|
|
if (cfg->cascaded_expander == 0xff && cfg->phy == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: Link rate=%s, WWN=%08X%08X\n",
|
|
path_status_desc[j].desc, path_type_desc[i].desc,
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
} else if (cfg->cascaded_expander == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: Phy=%d, Link rate=%s, "
|
|
"WWN=%08X%08X\n", path_status_desc[j].desc,
|
|
path_type_desc[i].desc, cfg->phy,
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
} else if (cfg->phy == 0xff) {
|
|
ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Link rate=%s, "
|
|
"WWN=%08X%08X\n", path_status_desc[j].desc,
|
|
path_type_desc[i].desc, cfg->cascaded_expander,
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
} else {
|
|
ipr_hcam_err(hostrcb, "%s %s: Cascade=%d, Phy=%d, Link rate=%s "
|
|
"WWN=%08X%08X\n", path_status_desc[j].desc,
|
|
path_type_desc[i].desc, cfg->cascaded_expander, cfg->phy,
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
}
|
|
}
|
|
return;
|
|
}
|
|
}
|
|
|
|
ipr_hcam_err(hostrcb, "Path element=%02X: Cascade=%d Phy=%d Link rate=%s "
|
|
"WWN=%08X%08X\n", cfg->type_status, cfg->cascaded_expander, cfg->phy,
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log64_path_elem - Log a fabric path element.
|
|
* @hostrcb: hostrcb struct
|
|
* @cfg: fabric path element struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log64_path_elem(struct ipr_hostrcb *hostrcb,
|
|
struct ipr_hostrcb64_config_element *cfg)
|
|
{
|
|
int i, j;
|
|
u8 desc_id = cfg->descriptor_id & IPR_DESCRIPTOR_MASK;
|
|
u8 type = cfg->type_status & IPR_PATH_CFG_TYPE_MASK;
|
|
u8 status = cfg->type_status & IPR_PATH_CFG_STATUS_MASK;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
if (type == IPR_PATH_CFG_NOT_EXIST || desc_id != IPR_DESCRIPTOR_SIS64)
|
|
return;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(path_type_desc); i++) {
|
|
if (path_type_desc[i].type != type)
|
|
continue;
|
|
|
|
for (j = 0; j < ARRAY_SIZE(path_status_desc); j++) {
|
|
if (path_status_desc[j].status != status)
|
|
continue;
|
|
|
|
ipr_hcam_err(hostrcb, "%s %s: Resource Path=%s, Link rate=%s, WWN=%08X%08X\n",
|
|
path_status_desc[j].desc, path_type_desc[i].desc,
|
|
ipr_format_res_path(hostrcb->ioa_cfg,
|
|
cfg->res_path, buffer, sizeof(buffer)),
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]),
|
|
be32_to_cpu(cfg->wwid[1]));
|
|
return;
|
|
}
|
|
}
|
|
ipr_hcam_err(hostrcb, "Path element=%02X: Resource Path=%s, Link rate=%s "
|
|
"WWN=%08X%08X\n", cfg->type_status,
|
|
ipr_format_res_path(hostrcb->ioa_cfg,
|
|
cfg->res_path, buffer, sizeof(buffer)),
|
|
link_rate[cfg->link_rate & IPR_PHY_LINK_RATE_MASK],
|
|
be32_to_cpu(cfg->wwid[0]), be32_to_cpu(cfg->wwid[1]));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_fabric_error - Log a fabric error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_20_error *error;
|
|
struct ipr_hostrcb_fabric_desc *fabric;
|
|
struct ipr_hostrcb_config_element *cfg;
|
|
int i, add_len;
|
|
|
|
error = &hostrcb->hcam.u.error.u.type_20_error;
|
|
error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
|
|
ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
|
|
|
|
add_len = be32_to_cpu(hostrcb->hcam.length) -
|
|
(offsetof(struct ipr_hostrcb_error, u) +
|
|
offsetof(struct ipr_hostrcb_type_20_error, desc));
|
|
|
|
for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
|
|
ipr_log_fabric_path(hostrcb, fabric);
|
|
for_each_fabric_cfg(fabric, cfg)
|
|
ipr_log_path_elem(hostrcb, cfg);
|
|
|
|
add_len -= be16_to_cpu(fabric->length);
|
|
fabric = (struct ipr_hostrcb_fabric_desc *)
|
|
((unsigned long)fabric + be16_to_cpu(fabric->length));
|
|
}
|
|
|
|
ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
|
|
}
|
|
|
|
/**
|
|
* ipr_log_sis64_array_error - Log a sis64 array error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_sis64_array_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
int i, num_entries;
|
|
struct ipr_hostrcb_type_24_error *error;
|
|
struct ipr_hostrcb64_array_data_entry *array_entry;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
const u8 zero_sn[IPR_SERIAL_NUM_LEN] = { [0 ... IPR_SERIAL_NUM_LEN-1] = '0' };
|
|
|
|
error = &hostrcb->hcam.u.error64.u.type_24_error;
|
|
|
|
ipr_err_separator;
|
|
|
|
ipr_err("RAID %s Array Configuration: %s\n",
|
|
error->protection_level,
|
|
ipr_format_res_path(ioa_cfg, error->last_res_path,
|
|
buffer, sizeof(buffer)));
|
|
|
|
ipr_err_separator;
|
|
|
|
array_entry = error->array_member;
|
|
num_entries = min_t(u32, error->num_entries,
|
|
ARRAY_SIZE(error->array_member));
|
|
|
|
for (i = 0; i < num_entries; i++, array_entry++) {
|
|
|
|
if (!memcmp(array_entry->vpd.vpd.sn, zero_sn, IPR_SERIAL_NUM_LEN))
|
|
continue;
|
|
|
|
if (error->exposed_mode_adn == i)
|
|
ipr_err("Exposed Array Member %d:\n", i);
|
|
else
|
|
ipr_err("Array Member %d:\n", i);
|
|
|
|
ipr_err("Array Member %d:\n", i);
|
|
ipr_log_ext_vpd(&array_entry->vpd);
|
|
ipr_err("Current Location: %s\n",
|
|
ipr_format_res_path(ioa_cfg, array_entry->res_path,
|
|
buffer, sizeof(buffer)));
|
|
ipr_err("Expected Location: %s\n",
|
|
ipr_format_res_path(ioa_cfg,
|
|
array_entry->expected_res_path,
|
|
buffer, sizeof(buffer)));
|
|
|
|
ipr_err_separator;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_log_sis64_fabric_error - Log a sis64 fabric error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_sis64_fabric_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_30_error *error;
|
|
struct ipr_hostrcb64_fabric_desc *fabric;
|
|
struct ipr_hostrcb64_config_element *cfg;
|
|
int i, add_len;
|
|
|
|
error = &hostrcb->hcam.u.error64.u.type_30_error;
|
|
|
|
error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
|
|
ipr_hcam_err(hostrcb, "%s\n", error->failure_reason);
|
|
|
|
add_len = be32_to_cpu(hostrcb->hcam.length) -
|
|
(offsetof(struct ipr_hostrcb64_error, u) +
|
|
offsetof(struct ipr_hostrcb_type_30_error, desc));
|
|
|
|
for (i = 0, fabric = error->desc; i < error->num_entries; i++) {
|
|
ipr_log64_fabric_path(hostrcb, fabric);
|
|
for_each_fabric_cfg(fabric, cfg)
|
|
ipr_log64_path_elem(hostrcb, cfg);
|
|
|
|
add_len -= be16_to_cpu(fabric->length);
|
|
fabric = (struct ipr_hostrcb64_fabric_desc *)
|
|
((unsigned long)fabric + be16_to_cpu(fabric->length));
|
|
}
|
|
|
|
ipr_log_hex_data(ioa_cfg, (__be32 *)fabric, add_len);
|
|
}
|
|
|
|
/**
|
|
* ipr_log_sis64_service_required_error - Log a sis64 service required error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_sis64_service_required_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_41_error *error;
|
|
|
|
error = &hostrcb->hcam.u.error64.u.type_41_error;
|
|
|
|
error->failure_reason[sizeof(error->failure_reason) - 1] = '\0';
|
|
ipr_err("Primary Failure Reason: %s\n", error->failure_reason);
|
|
ipr_log_hex_data(ioa_cfg, error->data,
|
|
be32_to_cpu(hostrcb->hcam.length) -
|
|
(offsetof(struct ipr_hostrcb_error, u) +
|
|
offsetof(struct ipr_hostrcb_type_41_error, data)));
|
|
}
|
|
/**
|
|
* ipr_log_generic_error - Log an adapter error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_generic_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
ipr_log_hex_data(ioa_cfg, hostrcb->hcam.u.raw.data,
|
|
be32_to_cpu(hostrcb->hcam.length));
|
|
}
|
|
|
|
/**
|
|
* ipr_log_sis64_device_error - Log a cache error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_log_sis64_device_error(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
struct ipr_hostrcb_type_21_error *error;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
error = &hostrcb->hcam.u.error64.u.type_21_error;
|
|
|
|
ipr_err("-----Failing Device Information-----\n");
|
|
ipr_err("World Wide Unique ID: %08X%08X%08X%08X\n",
|
|
be32_to_cpu(error->wwn[0]), be32_to_cpu(error->wwn[1]),
|
|
be32_to_cpu(error->wwn[2]), be32_to_cpu(error->wwn[3]));
|
|
ipr_err("Device Resource Path: %s\n",
|
|
__ipr_format_res_path(error->res_path,
|
|
buffer, sizeof(buffer)));
|
|
error->primary_problem_desc[sizeof(error->primary_problem_desc) - 1] = '\0';
|
|
error->second_problem_desc[sizeof(error->second_problem_desc) - 1] = '\0';
|
|
ipr_err("Primary Problem Description: %s\n", error->primary_problem_desc);
|
|
ipr_err("Secondary Problem Description: %s\n", error->second_problem_desc);
|
|
ipr_err("SCSI Sense Data:\n");
|
|
ipr_log_hex_data(ioa_cfg, error->sense_data, sizeof(error->sense_data));
|
|
ipr_err("SCSI Command Descriptor Block: \n");
|
|
ipr_log_hex_data(ioa_cfg, error->cdb, sizeof(error->cdb));
|
|
|
|
ipr_err("Additional IOA Data:\n");
|
|
ipr_log_hex_data(ioa_cfg, error->ioa_data, be32_to_cpu(error->length_of_error));
|
|
}
|
|
|
|
/**
|
|
* ipr_get_error - Find the specfied IOASC in the ipr_error_table.
|
|
* @ioasc: IOASC
|
|
*
|
|
* This function will return the index of into the ipr_error_table
|
|
* for the specified IOASC. If the IOASC is not in the table,
|
|
* 0 will be returned, which points to the entry used for unknown errors.
|
|
*
|
|
* Return value:
|
|
* index into the ipr_error_table
|
|
**/
|
|
static u32 ipr_get_error(u32 ioasc)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ipr_error_table); i++)
|
|
if (ipr_error_table[i].ioasc == (ioasc & IPR_IOASC_IOASC_MASK))
|
|
return i;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_handle_log_data - Log an adapter error.
|
|
* @ioa_cfg: ioa config struct
|
|
* @hostrcb: hostrcb struct
|
|
*
|
|
* This function logs an adapter error to the system.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_handle_log_data(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_hostrcb *hostrcb)
|
|
{
|
|
u32 ioasc;
|
|
int error_index;
|
|
struct ipr_hostrcb_type_21_error *error;
|
|
|
|
if (hostrcb->hcam.notify_type != IPR_HOST_RCB_NOTIF_TYPE_ERROR_LOG_ENTRY)
|
|
return;
|
|
|
|
if (hostrcb->hcam.notifications_lost == IPR_HOST_RCB_NOTIFICATIONS_LOST)
|
|
dev_err(&ioa_cfg->pdev->dev, "Error notifications lost\n");
|
|
|
|
if (ioa_cfg->sis64)
|
|
ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
|
|
else
|
|
ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
|
|
|
|
if (!ioa_cfg->sis64 && (ioasc == IPR_IOASC_BUS_WAS_RESET ||
|
|
ioasc == IPR_IOASC_BUS_WAS_RESET_BY_OTHER)) {
|
|
/* Tell the midlayer we had a bus reset so it will handle the UA properly */
|
|
scsi_report_bus_reset(ioa_cfg->host,
|
|
hostrcb->hcam.u.error.fd_res_addr.bus);
|
|
}
|
|
|
|
error_index = ipr_get_error(ioasc);
|
|
|
|
if (!ipr_error_table[error_index].log_hcam)
|
|
return;
|
|
|
|
if (ioasc == IPR_IOASC_HW_CMD_FAILED &&
|
|
hostrcb->hcam.overlay_id == IPR_HOST_RCB_OVERLAY_ID_21) {
|
|
error = &hostrcb->hcam.u.error64.u.type_21_error;
|
|
|
|
if (((be32_to_cpu(error->sense_data[0]) & 0x0000ff00) >> 8) == ILLEGAL_REQUEST &&
|
|
ioa_cfg->log_level <= IPR_DEFAULT_LOG_LEVEL)
|
|
return;
|
|
}
|
|
|
|
ipr_hcam_err(hostrcb, "%s\n", ipr_error_table[error_index].error);
|
|
|
|
/* Set indication we have logged an error */
|
|
ioa_cfg->errors_logged++;
|
|
|
|
if (ioa_cfg->log_level < ipr_error_table[error_index].log_hcam)
|
|
return;
|
|
if (be32_to_cpu(hostrcb->hcam.length) > sizeof(hostrcb->hcam.u.raw))
|
|
hostrcb->hcam.length = cpu_to_be32(sizeof(hostrcb->hcam.u.raw));
|
|
|
|
switch (hostrcb->hcam.overlay_id) {
|
|
case IPR_HOST_RCB_OVERLAY_ID_2:
|
|
ipr_log_cache_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_3:
|
|
ipr_log_config_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_4:
|
|
case IPR_HOST_RCB_OVERLAY_ID_6:
|
|
ipr_log_array_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_7:
|
|
ipr_log_dual_ioa_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_12:
|
|
ipr_log_enhanced_cache_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_13:
|
|
ipr_log_enhanced_config_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_14:
|
|
case IPR_HOST_RCB_OVERLAY_ID_16:
|
|
ipr_log_enhanced_array_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_17:
|
|
ipr_log_enhanced_dual_ioa_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_20:
|
|
ipr_log_fabric_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_21:
|
|
ipr_log_sis64_device_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_23:
|
|
ipr_log_sis64_config_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_24:
|
|
case IPR_HOST_RCB_OVERLAY_ID_26:
|
|
ipr_log_sis64_array_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_30:
|
|
ipr_log_sis64_fabric_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_41:
|
|
ipr_log_sis64_service_required_error(ioa_cfg, hostrcb);
|
|
break;
|
|
case IPR_HOST_RCB_OVERLAY_ID_1:
|
|
case IPR_HOST_RCB_OVERLAY_ID_DEFAULT:
|
|
default:
|
|
ipr_log_generic_error(ioa_cfg, hostrcb);
|
|
break;
|
|
}
|
|
}
|
|
|
|
static struct ipr_hostrcb *ipr_get_free_hostrcb(struct ipr_ioa_cfg *ioa)
|
|
{
|
|
struct ipr_hostrcb *hostrcb;
|
|
|
|
hostrcb = list_first_entry_or_null(&ioa->hostrcb_free_q,
|
|
struct ipr_hostrcb, queue);
|
|
|
|
if (unlikely(!hostrcb)) {
|
|
dev_info(&ioa->pdev->dev, "Reclaiming async error buffers.");
|
|
hostrcb = list_first_entry_or_null(&ioa->hostrcb_report_q,
|
|
struct ipr_hostrcb, queue);
|
|
}
|
|
|
|
list_del_init(&hostrcb->queue);
|
|
return hostrcb;
|
|
}
|
|
|
|
/**
|
|
* ipr_process_error - Op done function for an adapter error log.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is the op done function for an error log host
|
|
* controlled async from the adapter. It will log the error and
|
|
* send the HCAM back to the adapter.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_process_error(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_hostrcb *hostrcb = ipr_cmd->u.hostrcb;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
u32 fd_ioasc;
|
|
|
|
if (ioa_cfg->sis64)
|
|
fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error64.fd_ioasc);
|
|
else
|
|
fd_ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
|
|
|
|
list_del_init(&hostrcb->queue);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
|
|
if (!ioasc) {
|
|
ipr_handle_log_data(ioa_cfg, hostrcb);
|
|
if (fd_ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED)
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
|
|
} else if (ioasc != IPR_IOASC_IOA_WAS_RESET &&
|
|
ioasc != IPR_IOASC_ABORTED_CMD_TERM_BY_HOST) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Host RCB failed with IOASC: 0x%08X\n", ioasc);
|
|
}
|
|
|
|
list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_report_q);
|
|
schedule_work(&ioa_cfg->work_q);
|
|
hostrcb = ipr_get_free_hostrcb(ioa_cfg);
|
|
|
|
ipr_send_hcam(ioa_cfg, IPR_HCAM_CDB_OP_CODE_LOG_DATA, hostrcb);
|
|
}
|
|
|
|
/**
|
|
* ipr_timeout - An internally generated op has timed out.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function blocks host requests and initiates an
|
|
* adapter reset.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_timeout(struct timer_list *t)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
|
|
unsigned long lock_flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
ioa_cfg->errors_logged++;
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Adapter being reset due to command timeout.\n");
|
|
|
|
if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
|
|
ioa_cfg->sdt_state = GET_DUMP;
|
|
|
|
if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd)
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_oper_timeout - Adapter timed out transitioning to operational
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function blocks host requests and initiates an
|
|
* adapter reset.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_oper_timeout(struct timer_list *t)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
|
|
unsigned long lock_flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
ioa_cfg->errors_logged++;
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Adapter timed out transitioning to operational.\n");
|
|
|
|
if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
|
|
ioa_cfg->sdt_state = GET_DUMP;
|
|
|
|
if (!ioa_cfg->in_reset_reload || ioa_cfg->reset_cmd == ipr_cmd) {
|
|
if (ipr_fastfail)
|
|
ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
}
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_find_ses_entry - Find matching SES in SES table
|
|
* @res: resource entry struct of SES
|
|
*
|
|
* Return value:
|
|
* pointer to SES table entry / NULL on failure
|
|
**/
|
|
static const struct ipr_ses_table_entry *
|
|
ipr_find_ses_entry(struct ipr_resource_entry *res)
|
|
{
|
|
int i, j, matches;
|
|
struct ipr_std_inq_vpids *vpids;
|
|
const struct ipr_ses_table_entry *ste = ipr_ses_table;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ipr_ses_table); i++, ste++) {
|
|
for (j = 0, matches = 0; j < IPR_PROD_ID_LEN; j++) {
|
|
if (ste->compare_product_id_byte[j] == 'X') {
|
|
vpids = &res->std_inq_data.vpids;
|
|
if (vpids->product_id[j] == ste->product_id[j])
|
|
matches++;
|
|
else
|
|
break;
|
|
} else
|
|
matches++;
|
|
}
|
|
|
|
if (matches == IPR_PROD_ID_LEN)
|
|
return ste;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_max_scsi_speed - Determine max SCSI speed for a given bus
|
|
* @ioa_cfg: ioa config struct
|
|
* @bus: SCSI bus
|
|
* @bus_width: bus width
|
|
*
|
|
* Return value:
|
|
* SCSI bus speed in units of 100KHz, 1600 is 160 MHz
|
|
* For a 2-byte wide SCSI bus, the maximum transfer speed is
|
|
* twice the maximum transfer rate (e.g. for a wide enabled bus,
|
|
* max 160MHz = max 320MB/sec).
|
|
**/
|
|
static u32 ipr_get_max_scsi_speed(struct ipr_ioa_cfg *ioa_cfg, u8 bus, u8 bus_width)
|
|
{
|
|
struct ipr_resource_entry *res;
|
|
const struct ipr_ses_table_entry *ste;
|
|
u32 max_xfer_rate = IPR_MAX_SCSI_RATE(bus_width);
|
|
|
|
/* Loop through each config table entry in the config table buffer */
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (!(IPR_IS_SES_DEVICE(res->std_inq_data)))
|
|
continue;
|
|
|
|
if (bus != res->bus)
|
|
continue;
|
|
|
|
if (!(ste = ipr_find_ses_entry(res)))
|
|
continue;
|
|
|
|
max_xfer_rate = (ste->max_bus_speed_limit * 10) / (bus_width / 8);
|
|
}
|
|
|
|
return max_xfer_rate;
|
|
}
|
|
|
|
/**
|
|
* ipr_wait_iodbg_ack - Wait for an IODEBUG ACK from the IOA
|
|
* @ioa_cfg: ioa config struct
|
|
* @max_delay: max delay in micro-seconds to wait
|
|
*
|
|
* Waits for an IODEBUG ACK from the IOA, doing busy looping.
|
|
*
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_wait_iodbg_ack(struct ipr_ioa_cfg *ioa_cfg, int max_delay)
|
|
{
|
|
volatile u32 pcii_reg;
|
|
int delay = 1;
|
|
|
|
/* Read interrupt reg until IOA signals IO Debug Acknowledge */
|
|
while (delay < max_delay) {
|
|
pcii_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
|
|
if (pcii_reg & IPR_PCII_IO_DEBUG_ACKNOWLEDGE)
|
|
return 0;
|
|
|
|
/* udelay cannot be used if delay is more than a few milliseconds */
|
|
if ((delay / 1000) > MAX_UDELAY_MS)
|
|
mdelay(delay / 1000);
|
|
else
|
|
udelay(delay);
|
|
|
|
delay += delay;
|
|
}
|
|
return -EIO;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_sis64_dump_data_section - Dump IOA memory
|
|
* @ioa_cfg: ioa config struct
|
|
* @start_addr: adapter address to dump
|
|
* @dest: destination kernel buffer
|
|
* @length_in_words: length to dump in 4 byte words
|
|
*
|
|
* Return value:
|
|
* 0 on success
|
|
**/
|
|
static int ipr_get_sis64_dump_data_section(struct ipr_ioa_cfg *ioa_cfg,
|
|
u32 start_addr,
|
|
__be32 *dest, u32 length_in_words)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < length_in_words; i++) {
|
|
writel(start_addr+(i*4), ioa_cfg->regs.dump_addr_reg);
|
|
*dest = cpu_to_be32(readl(ioa_cfg->regs.dump_data_reg));
|
|
dest++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_ldump_data_section - Dump IOA memory
|
|
* @ioa_cfg: ioa config struct
|
|
* @start_addr: adapter address to dump
|
|
* @dest: destination kernel buffer
|
|
* @length_in_words: length to dump in 4 byte words
|
|
*
|
|
* Return value:
|
|
* 0 on success / -EIO on failure
|
|
**/
|
|
static int ipr_get_ldump_data_section(struct ipr_ioa_cfg *ioa_cfg,
|
|
u32 start_addr,
|
|
__be32 *dest, u32 length_in_words)
|
|
{
|
|
volatile u32 temp_pcii_reg;
|
|
int i, delay = 0;
|
|
|
|
if (ioa_cfg->sis64)
|
|
return ipr_get_sis64_dump_data_section(ioa_cfg, start_addr,
|
|
dest, length_in_words);
|
|
|
|
/* Write IOA interrupt reg starting LDUMP state */
|
|
writel((IPR_UPROCI_RESET_ALERT | IPR_UPROCI_IO_DEBUG_ALERT),
|
|
ioa_cfg->regs.set_uproc_interrupt_reg32);
|
|
|
|
/* Wait for IO debug acknowledge */
|
|
if (ipr_wait_iodbg_ack(ioa_cfg,
|
|
IPR_LDUMP_MAX_LONG_ACK_DELAY_IN_USEC)) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"IOA dump long data transfer timeout\n");
|
|
return -EIO;
|
|
}
|
|
|
|
/* Signal LDUMP interlocked - clear IO debug ack */
|
|
writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
|
|
ioa_cfg->regs.clr_interrupt_reg);
|
|
|
|
/* Write Mailbox with starting address */
|
|
writel(start_addr, ioa_cfg->ioa_mailbox);
|
|
|
|
/* Signal address valid - clear IOA Reset alert */
|
|
writel(IPR_UPROCI_RESET_ALERT,
|
|
ioa_cfg->regs.clr_uproc_interrupt_reg32);
|
|
|
|
for (i = 0; i < length_in_words; i++) {
|
|
/* Wait for IO debug acknowledge */
|
|
if (ipr_wait_iodbg_ack(ioa_cfg,
|
|
IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC)) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"IOA dump short data transfer timeout\n");
|
|
return -EIO;
|
|
}
|
|
|
|
/* Read data from mailbox and increment destination pointer */
|
|
*dest = cpu_to_be32(readl(ioa_cfg->ioa_mailbox));
|
|
dest++;
|
|
|
|
/* For all but the last word of data, signal data received */
|
|
if (i < (length_in_words - 1)) {
|
|
/* Signal dump data received - Clear IO debug Ack */
|
|
writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
|
|
ioa_cfg->regs.clr_interrupt_reg);
|
|
}
|
|
}
|
|
|
|
/* Signal end of block transfer. Set reset alert then clear IO debug ack */
|
|
writel(IPR_UPROCI_RESET_ALERT,
|
|
ioa_cfg->regs.set_uproc_interrupt_reg32);
|
|
|
|
writel(IPR_UPROCI_IO_DEBUG_ALERT,
|
|
ioa_cfg->regs.clr_uproc_interrupt_reg32);
|
|
|
|
/* Signal dump data received - Clear IO debug Ack */
|
|
writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE,
|
|
ioa_cfg->regs.clr_interrupt_reg);
|
|
|
|
/* Wait for IOA to signal LDUMP exit - IOA reset alert will be cleared */
|
|
while (delay < IPR_LDUMP_MAX_SHORT_ACK_DELAY_IN_USEC) {
|
|
temp_pcii_reg =
|
|
readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
|
|
|
|
if (!(temp_pcii_reg & IPR_UPROCI_RESET_ALERT))
|
|
return 0;
|
|
|
|
udelay(10);
|
|
delay += 10;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
#ifdef CONFIG_SCSI_IPR_DUMP
|
|
/**
|
|
* ipr_sdt_copy - Copy Smart Dump Table to kernel buffer
|
|
* @ioa_cfg: ioa config struct
|
|
* @pci_address: adapter address
|
|
* @length: length of data to copy
|
|
*
|
|
* Copy data from PCI adapter to kernel buffer.
|
|
* Note: length MUST be a 4 byte multiple
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_sdt_copy(struct ipr_ioa_cfg *ioa_cfg,
|
|
unsigned long pci_address, u32 length)
|
|
{
|
|
int bytes_copied = 0;
|
|
int cur_len, rc, rem_len, rem_page_len, max_dump_size;
|
|
__be32 *page;
|
|
unsigned long lock_flags = 0;
|
|
struct ipr_ioa_dump *ioa_dump = &ioa_cfg->dump->ioa_dump;
|
|
|
|
if (ioa_cfg->sis64)
|
|
max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
|
|
else
|
|
max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
|
|
|
|
while (bytes_copied < length &&
|
|
(ioa_dump->hdr.len + bytes_copied) < max_dump_size) {
|
|
if (ioa_dump->page_offset >= PAGE_SIZE ||
|
|
ioa_dump->page_offset == 0) {
|
|
page = (__be32 *)__get_free_page(GFP_ATOMIC);
|
|
|
|
if (!page) {
|
|
ipr_trace;
|
|
return bytes_copied;
|
|
}
|
|
|
|
ioa_dump->page_offset = 0;
|
|
ioa_dump->ioa_data[ioa_dump->next_page_index] = page;
|
|
ioa_dump->next_page_index++;
|
|
} else
|
|
page = ioa_dump->ioa_data[ioa_dump->next_page_index - 1];
|
|
|
|
rem_len = length - bytes_copied;
|
|
rem_page_len = PAGE_SIZE - ioa_dump->page_offset;
|
|
cur_len = min(rem_len, rem_page_len);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->sdt_state == ABORT_DUMP) {
|
|
rc = -EIO;
|
|
} else {
|
|
rc = ipr_get_ldump_data_section(ioa_cfg,
|
|
pci_address + bytes_copied,
|
|
&page[ioa_dump->page_offset / 4],
|
|
(cur_len / sizeof(u32)));
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (!rc) {
|
|
ioa_dump->page_offset += cur_len;
|
|
bytes_copied += cur_len;
|
|
} else {
|
|
ipr_trace;
|
|
break;
|
|
}
|
|
schedule();
|
|
}
|
|
|
|
return bytes_copied;
|
|
}
|
|
|
|
/**
|
|
* ipr_init_dump_entry_hdr - Initialize a dump entry header.
|
|
* @hdr: dump entry header struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_init_dump_entry_hdr(struct ipr_dump_entry_header *hdr)
|
|
{
|
|
hdr->eye_catcher = IPR_DUMP_EYE_CATCHER;
|
|
hdr->num_elems = 1;
|
|
hdr->offset = sizeof(*hdr);
|
|
hdr->status = IPR_DUMP_STATUS_SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* ipr_dump_ioa_type_data - Fill in the adapter type in the dump.
|
|
* @ioa_cfg: ioa config struct
|
|
* @driver_dump: driver dump struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_dump_ioa_type_data(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_driver_dump *driver_dump)
|
|
{
|
|
struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
|
|
|
|
ipr_init_dump_entry_hdr(&driver_dump->ioa_type_entry.hdr);
|
|
driver_dump->ioa_type_entry.hdr.len =
|
|
sizeof(struct ipr_dump_ioa_type_entry) -
|
|
sizeof(struct ipr_dump_entry_header);
|
|
driver_dump->ioa_type_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
|
|
driver_dump->ioa_type_entry.hdr.id = IPR_DUMP_DRIVER_TYPE_ID;
|
|
driver_dump->ioa_type_entry.type = ioa_cfg->type;
|
|
driver_dump->ioa_type_entry.fw_version = (ucode_vpd->major_release << 24) |
|
|
(ucode_vpd->card_type << 16) | (ucode_vpd->minor_release[0] << 8) |
|
|
ucode_vpd->minor_release[1];
|
|
driver_dump->hdr.num_entries++;
|
|
}
|
|
|
|
/**
|
|
* ipr_dump_version_data - Fill in the driver version in the dump.
|
|
* @ioa_cfg: ioa config struct
|
|
* @driver_dump: driver dump struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_dump_version_data(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_driver_dump *driver_dump)
|
|
{
|
|
ipr_init_dump_entry_hdr(&driver_dump->version_entry.hdr);
|
|
driver_dump->version_entry.hdr.len =
|
|
sizeof(struct ipr_dump_version_entry) -
|
|
sizeof(struct ipr_dump_entry_header);
|
|
driver_dump->version_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
|
|
driver_dump->version_entry.hdr.id = IPR_DUMP_DRIVER_VERSION_ID;
|
|
strcpy(driver_dump->version_entry.version, IPR_DRIVER_VERSION);
|
|
driver_dump->hdr.num_entries++;
|
|
}
|
|
|
|
/**
|
|
* ipr_dump_trace_data - Fill in the IOA trace in the dump.
|
|
* @ioa_cfg: ioa config struct
|
|
* @driver_dump: driver dump struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_dump_trace_data(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_driver_dump *driver_dump)
|
|
{
|
|
ipr_init_dump_entry_hdr(&driver_dump->trace_entry.hdr);
|
|
driver_dump->trace_entry.hdr.len =
|
|
sizeof(struct ipr_dump_trace_entry) -
|
|
sizeof(struct ipr_dump_entry_header);
|
|
driver_dump->trace_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
|
|
driver_dump->trace_entry.hdr.id = IPR_DUMP_TRACE_ID;
|
|
memcpy(driver_dump->trace_entry.trace, ioa_cfg->trace, IPR_TRACE_SIZE);
|
|
driver_dump->hdr.num_entries++;
|
|
}
|
|
|
|
/**
|
|
* ipr_dump_location_data - Fill in the IOA location in the dump.
|
|
* @ioa_cfg: ioa config struct
|
|
* @driver_dump: driver dump struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_dump_location_data(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_driver_dump *driver_dump)
|
|
{
|
|
ipr_init_dump_entry_hdr(&driver_dump->location_entry.hdr);
|
|
driver_dump->location_entry.hdr.len =
|
|
sizeof(struct ipr_dump_location_entry) -
|
|
sizeof(struct ipr_dump_entry_header);
|
|
driver_dump->location_entry.hdr.data_type = IPR_DUMP_DATA_TYPE_ASCII;
|
|
driver_dump->location_entry.hdr.id = IPR_DUMP_LOCATION_ID;
|
|
strcpy(driver_dump->location_entry.location, dev_name(&ioa_cfg->pdev->dev));
|
|
driver_dump->hdr.num_entries++;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_ioa_dump - Perform a dump of the driver and adapter.
|
|
* @ioa_cfg: ioa config struct
|
|
* @dump: dump struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_get_ioa_dump(struct ipr_ioa_cfg *ioa_cfg, struct ipr_dump *dump)
|
|
{
|
|
unsigned long start_addr, sdt_word;
|
|
unsigned long lock_flags = 0;
|
|
struct ipr_driver_dump *driver_dump = &dump->driver_dump;
|
|
struct ipr_ioa_dump *ioa_dump = &dump->ioa_dump;
|
|
u32 num_entries, max_num_entries, start_off, end_off;
|
|
u32 max_dump_size, bytes_to_copy, bytes_copied, rc;
|
|
struct ipr_sdt *sdt;
|
|
int valid = 1;
|
|
int i;
|
|
|
|
ENTER;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (ioa_cfg->sdt_state != READ_DUMP) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
if (ioa_cfg->sis64) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
ssleep(IPR_DUMP_DELAY_SECONDS);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
start_addr = readl(ioa_cfg->ioa_mailbox);
|
|
|
|
if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(start_addr)) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Invalid dump table format: %lx\n", start_addr);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
dev_err(&ioa_cfg->pdev->dev, "Dump of IOA initiated\n");
|
|
|
|
driver_dump->hdr.eye_catcher = IPR_DUMP_EYE_CATCHER;
|
|
|
|
/* Initialize the overall dump header */
|
|
driver_dump->hdr.len = sizeof(struct ipr_driver_dump);
|
|
driver_dump->hdr.num_entries = 1;
|
|
driver_dump->hdr.first_entry_offset = sizeof(struct ipr_dump_header);
|
|
driver_dump->hdr.status = IPR_DUMP_STATUS_SUCCESS;
|
|
driver_dump->hdr.os = IPR_DUMP_OS_LINUX;
|
|
driver_dump->hdr.driver_name = IPR_DUMP_DRIVER_NAME;
|
|
|
|
ipr_dump_version_data(ioa_cfg, driver_dump);
|
|
ipr_dump_location_data(ioa_cfg, driver_dump);
|
|
ipr_dump_ioa_type_data(ioa_cfg, driver_dump);
|
|
ipr_dump_trace_data(ioa_cfg, driver_dump);
|
|
|
|
/* Update dump_header */
|
|
driver_dump->hdr.len += sizeof(struct ipr_dump_entry_header);
|
|
|
|
/* IOA Dump entry */
|
|
ipr_init_dump_entry_hdr(&ioa_dump->hdr);
|
|
ioa_dump->hdr.len = 0;
|
|
ioa_dump->hdr.data_type = IPR_DUMP_DATA_TYPE_BINARY;
|
|
ioa_dump->hdr.id = IPR_DUMP_IOA_DUMP_ID;
|
|
|
|
/* First entries in sdt are actually a list of dump addresses and
|
|
lengths to gather the real dump data. sdt represents the pointer
|
|
to the ioa generated dump table. Dump data will be extracted based
|
|
on entries in this table */
|
|
sdt = &ioa_dump->sdt;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
max_num_entries = IPR_FMT3_NUM_SDT_ENTRIES;
|
|
max_dump_size = IPR_FMT3_MAX_IOA_DUMP_SIZE;
|
|
} else {
|
|
max_num_entries = IPR_FMT2_NUM_SDT_ENTRIES;
|
|
max_dump_size = IPR_FMT2_MAX_IOA_DUMP_SIZE;
|
|
}
|
|
|
|
bytes_to_copy = offsetof(struct ipr_sdt, entry) +
|
|
(max_num_entries * sizeof(struct ipr_sdt_entry));
|
|
rc = ipr_get_ldump_data_section(ioa_cfg, start_addr, (__be32 *)sdt,
|
|
bytes_to_copy / sizeof(__be32));
|
|
|
|
/* Smart Dump table is ready to use and the first entry is valid */
|
|
if (rc || ((be32_to_cpu(sdt->hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
|
|
(be32_to_cpu(sdt->hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Dump of IOA failed. Dump table not valid: %d, %X.\n",
|
|
rc, be32_to_cpu(sdt->hdr.state));
|
|
driver_dump->hdr.status = IPR_DUMP_STATUS_FAILED;
|
|
ioa_cfg->sdt_state = DUMP_OBTAINED;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
num_entries = be32_to_cpu(sdt->hdr.num_entries_used);
|
|
|
|
if (num_entries > max_num_entries)
|
|
num_entries = max_num_entries;
|
|
|
|
/* Update dump length to the actual data to be copied */
|
|
dump->driver_dump.hdr.len += sizeof(struct ipr_sdt_header);
|
|
if (ioa_cfg->sis64)
|
|
dump->driver_dump.hdr.len += num_entries * sizeof(struct ipr_sdt_entry);
|
|
else
|
|
dump->driver_dump.hdr.len += max_num_entries * sizeof(struct ipr_sdt_entry);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
for (i = 0; i < num_entries; i++) {
|
|
if (ioa_dump->hdr.len > max_dump_size) {
|
|
driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
|
|
break;
|
|
}
|
|
|
|
if (sdt->entry[i].flags & IPR_SDT_VALID_ENTRY) {
|
|
sdt_word = be32_to_cpu(sdt->entry[i].start_token);
|
|
if (ioa_cfg->sis64)
|
|
bytes_to_copy = be32_to_cpu(sdt->entry[i].end_token);
|
|
else {
|
|
start_off = sdt_word & IPR_FMT2_MBX_ADDR_MASK;
|
|
end_off = be32_to_cpu(sdt->entry[i].end_token);
|
|
|
|
if (ipr_sdt_is_fmt2(sdt_word) && sdt_word)
|
|
bytes_to_copy = end_off - start_off;
|
|
else
|
|
valid = 0;
|
|
}
|
|
if (valid) {
|
|
if (bytes_to_copy > max_dump_size) {
|
|
sdt->entry[i].flags &= ~IPR_SDT_VALID_ENTRY;
|
|
continue;
|
|
}
|
|
|
|
/* Copy data from adapter to driver buffers */
|
|
bytes_copied = ipr_sdt_copy(ioa_cfg, sdt_word,
|
|
bytes_to_copy);
|
|
|
|
ioa_dump->hdr.len += bytes_copied;
|
|
|
|
if (bytes_copied != bytes_to_copy) {
|
|
driver_dump->hdr.status = IPR_DUMP_STATUS_QUAL_SUCCESS;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
}
|
|
|
|
dev_err(&ioa_cfg->pdev->dev, "Dump of IOA completed.\n");
|
|
|
|
/* Update dump_header */
|
|
driver_dump->hdr.len += ioa_dump->hdr.len;
|
|
wmb();
|
|
ioa_cfg->sdt_state = DUMP_OBTAINED;
|
|
LEAVE;
|
|
}
|
|
|
|
#else
|
|
#define ipr_get_ioa_dump(ioa_cfg, dump) do { } while (0)
|
|
#endif
|
|
|
|
/**
|
|
* ipr_release_dump - Free adapter dump memory
|
|
* @kref: kref struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_release_dump(struct kref *kref)
|
|
{
|
|
struct ipr_dump *dump = container_of(kref, struct ipr_dump, kref);
|
|
struct ipr_ioa_cfg *ioa_cfg = dump->ioa_cfg;
|
|
unsigned long lock_flags = 0;
|
|
int i;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ioa_cfg->dump = NULL;
|
|
ioa_cfg->sdt_state = INACTIVE;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
for (i = 0; i < dump->ioa_dump.next_page_index; i++)
|
|
free_page((unsigned long) dump->ioa_dump.ioa_data[i]);
|
|
|
|
vfree(dump->ioa_dump.ioa_data);
|
|
kfree(dump);
|
|
LEAVE;
|
|
}
|
|
|
|
static void ipr_add_remove_thread(struct work_struct *work)
|
|
{
|
|
unsigned long lock_flags;
|
|
struct ipr_resource_entry *res;
|
|
struct scsi_device *sdev;
|
|
struct ipr_ioa_cfg *ioa_cfg =
|
|
container_of(work, struct ipr_ioa_cfg, scsi_add_work_q);
|
|
u8 bus, target, lun;
|
|
int did_work;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
restart:
|
|
do {
|
|
did_work = 0;
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (res->del_from_ml && res->sdev) {
|
|
did_work = 1;
|
|
sdev = res->sdev;
|
|
if (!scsi_device_get(sdev)) {
|
|
if (!res->add_to_ml)
|
|
list_move_tail(&res->queue, &ioa_cfg->free_res_q);
|
|
else
|
|
res->del_from_ml = 0;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
scsi_remove_device(sdev);
|
|
scsi_device_put(sdev);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
break;
|
|
}
|
|
}
|
|
} while (did_work);
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (res->add_to_ml) {
|
|
bus = res->bus;
|
|
target = res->target;
|
|
lun = res->lun;
|
|
res->add_to_ml = 0;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
scsi_add_device(ioa_cfg->host, bus, target, lun);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
goto restart;
|
|
}
|
|
}
|
|
|
|
ioa_cfg->scan_done = 1;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
kobject_uevent(&ioa_cfg->host->shost_dev.kobj, KOBJ_CHANGE);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_worker_thread - Worker thread
|
|
* @work: ioa config struct
|
|
*
|
|
* Called at task level from a work thread. This function takes care
|
|
* of adding and removing device from the mid-layer as configuration
|
|
* changes are detected by the adapter.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_worker_thread(struct work_struct *work)
|
|
{
|
|
unsigned long lock_flags;
|
|
struct ipr_dump *dump;
|
|
struct ipr_ioa_cfg *ioa_cfg =
|
|
container_of(work, struct ipr_ioa_cfg, work_q);
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (ioa_cfg->sdt_state == READ_DUMP) {
|
|
dump = ioa_cfg->dump;
|
|
if (!dump) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
kref_get(&dump->kref);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
ipr_get_ioa_dump(ioa_cfg, dump);
|
|
kref_put(&dump->kref, ipr_release_dump);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->sdt_state == DUMP_OBTAINED && !ioa_cfg->dump_timeout)
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
if (ioa_cfg->scsi_unblock) {
|
|
ioa_cfg->scsi_unblock = 0;
|
|
ioa_cfg->scsi_blocked = 0;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
scsi_unblock_requests(ioa_cfg->host);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->scsi_blocked)
|
|
scsi_block_requests(ioa_cfg->host);
|
|
}
|
|
|
|
if (!ioa_cfg->scan_enabled) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
schedule_work(&ioa_cfg->scsi_add_work_q);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
}
|
|
|
|
#ifdef CONFIG_SCSI_IPR_TRACE
|
|
/**
|
|
* ipr_read_trace - Dump the adapter trace
|
|
* @filp: open sysfs file
|
|
* @kobj: kobject struct
|
|
* @bin_attr: bin_attribute struct
|
|
* @buf: buffer
|
|
* @off: offset
|
|
* @count: buffer size
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_read_trace(struct file *filp, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr,
|
|
char *buf, loff_t off, size_t count)
|
|
{
|
|
struct device *dev = container_of(kobj, struct device, kobj);
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t ret;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ret = memory_read_from_buffer(buf, count, &off, ioa_cfg->trace,
|
|
IPR_TRACE_SIZE);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
return ret;
|
|
}
|
|
|
|
static struct bin_attribute ipr_trace_attr = {
|
|
.attr = {
|
|
.name = "trace",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.size = 0,
|
|
.read = ipr_read_trace,
|
|
};
|
|
#endif
|
|
|
|
/**
|
|
* ipr_show_fw_version - Show the firmware version
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_fw_version(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
|
|
unsigned long lock_flags = 0;
|
|
int len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
len = snprintf(buf, PAGE_SIZE, "%02X%02X%02X%02X\n",
|
|
ucode_vpd->major_release, ucode_vpd->card_type,
|
|
ucode_vpd->minor_release[0],
|
|
ucode_vpd->minor_release[1]);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_fw_version_attr = {
|
|
.attr = {
|
|
.name = "fw_version",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.show = ipr_show_fw_version,
|
|
};
|
|
|
|
/**
|
|
* ipr_show_log_level - Show the adapter's error logging level
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_log_level(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
int len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->log_level);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* ipr_store_log_level - Change the adapter's error logging level
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_store_log_level(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ioa_cfg->log_level = simple_strtoul(buf, NULL, 10);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return strlen(buf);
|
|
}
|
|
|
|
static struct device_attribute ipr_log_level_attr = {
|
|
.attr = {
|
|
.name = "log_level",
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
},
|
|
.show = ipr_show_log_level,
|
|
.store = ipr_store_log_level
|
|
};
|
|
|
|
/**
|
|
* ipr_store_diagnostics - IOA Diagnostics interface
|
|
* @dev: device struct
|
|
* @buf: buffer
|
|
* @count: buffer size
|
|
*
|
|
* This function will reset the adapter and wait a reasonable
|
|
* amount of time for any errors that the adapter might log.
|
|
*
|
|
* Return value:
|
|
* count on success / other on failure
|
|
**/
|
|
static ssize_t ipr_store_diagnostics(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
int rc = count;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
ioa_cfg->errors_logged = 0;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
|
|
|
|
if (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
|
|
/* Wait for a second for any errors to be logged */
|
|
msleep(1000);
|
|
} else {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return -EIO;
|
|
}
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->in_reset_reload || ioa_cfg->errors_logged)
|
|
rc = -EIO;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
return rc;
|
|
}
|
|
|
|
static struct device_attribute ipr_diagnostics_attr = {
|
|
.attr = {
|
|
.name = "run_diagnostics",
|
|
.mode = S_IWUSR,
|
|
},
|
|
.store = ipr_store_diagnostics
|
|
};
|
|
|
|
/**
|
|
* ipr_show_adapter_state - Show the adapter's state
|
|
* @class_dev: device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_adapter_state(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
int len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
|
|
len = snprintf(buf, PAGE_SIZE, "offline\n");
|
|
else
|
|
len = snprintf(buf, PAGE_SIZE, "online\n");
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* ipr_store_adapter_state - Change adapter state
|
|
* @dev: device struct
|
|
* @buf: buffer
|
|
* @count: buffer size
|
|
*
|
|
* This function will change the adapter's state.
|
|
*
|
|
* Return value:
|
|
* count on success / other on failure
|
|
**/
|
|
static ssize_t ipr_store_adapter_state(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags;
|
|
int result = count, i;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead &&
|
|
!strncmp(buf, "online", 6)) {
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].ioa_is_dead = 0;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
ioa_cfg->reset_retries = 0;
|
|
ioa_cfg->in_ioa_bringdown = 0;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
|
|
return result;
|
|
}
|
|
|
|
static struct device_attribute ipr_ioa_state_attr = {
|
|
.attr = {
|
|
.name = "online_state",
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
},
|
|
.show = ipr_show_adapter_state,
|
|
.store = ipr_store_adapter_state
|
|
};
|
|
|
|
/**
|
|
* ipr_store_reset_adapter - Reset the adapter
|
|
* @dev: device struct
|
|
* @buf: buffer
|
|
* @count: buffer size
|
|
*
|
|
* This function will reset the adapter.
|
|
*
|
|
* Return value:
|
|
* count on success / other on failure
|
|
**/
|
|
static ssize_t ipr_store_reset_adapter(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags;
|
|
int result = count;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (!ioa_cfg->in_reset_reload)
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
|
|
return result;
|
|
}
|
|
|
|
static struct device_attribute ipr_ioa_reset_attr = {
|
|
.attr = {
|
|
.name = "reset_host",
|
|
.mode = S_IWUSR,
|
|
},
|
|
.store = ipr_store_reset_adapter
|
|
};
|
|
|
|
static int ipr_iopoll(struct irq_poll *iop, int budget);
|
|
/**
|
|
* ipr_show_iopoll_weight - Show ipr polling mode
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_iopoll_weight(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
int len;
|
|
|
|
spin_lock_irqsave(shost->host_lock, lock_flags);
|
|
len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->iopoll_weight);
|
|
spin_unlock_irqrestore(shost->host_lock, lock_flags);
|
|
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* ipr_store_iopoll_weight - Change the adapter's polling mode
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_store_iopoll_weight(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long user_iopoll_weight;
|
|
unsigned long lock_flags = 0;
|
|
int i;
|
|
|
|
if (!ioa_cfg->sis64) {
|
|
dev_info(&ioa_cfg->pdev->dev, "irq_poll not supported on this adapter\n");
|
|
return -EINVAL;
|
|
}
|
|
if (kstrtoul(buf, 10, &user_iopoll_weight))
|
|
return -EINVAL;
|
|
|
|
if (user_iopoll_weight > 256) {
|
|
dev_info(&ioa_cfg->pdev->dev, "Invalid irq_poll weight. It must be less than 256\n");
|
|
return -EINVAL;
|
|
}
|
|
|
|
if (user_iopoll_weight == ioa_cfg->iopoll_weight) {
|
|
dev_info(&ioa_cfg->pdev->dev, "Current irq_poll weight has the same weight\n");
|
|
return strlen(buf);
|
|
}
|
|
|
|
if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
|
|
for (i = 1; i < ioa_cfg->hrrq_num; i++)
|
|
irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
|
|
}
|
|
|
|
spin_lock_irqsave(shost->host_lock, lock_flags);
|
|
ioa_cfg->iopoll_weight = user_iopoll_weight;
|
|
if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
|
|
for (i = 1; i < ioa_cfg->hrrq_num; i++) {
|
|
irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
|
|
ioa_cfg->iopoll_weight, ipr_iopoll);
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(shost->host_lock, lock_flags);
|
|
|
|
return strlen(buf);
|
|
}
|
|
|
|
static struct device_attribute ipr_iopoll_weight_attr = {
|
|
.attr = {
|
|
.name = "iopoll_weight",
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
},
|
|
.show = ipr_show_iopoll_weight,
|
|
.store = ipr_store_iopoll_weight
|
|
};
|
|
|
|
/**
|
|
* ipr_alloc_ucode_buffer - Allocates a microcode download buffer
|
|
* @buf_len: buffer length
|
|
*
|
|
* Allocates a DMA'able buffer in chunks and assembles a scatter/gather
|
|
* list to use for microcode download
|
|
*
|
|
* Return value:
|
|
* pointer to sglist / NULL on failure
|
|
**/
|
|
static struct ipr_sglist *ipr_alloc_ucode_buffer(int buf_len)
|
|
{
|
|
int sg_size, order;
|
|
struct ipr_sglist *sglist;
|
|
|
|
/* Get the minimum size per scatter/gather element */
|
|
sg_size = buf_len / (IPR_MAX_SGLIST - 1);
|
|
|
|
/* Get the actual size per element */
|
|
order = get_order(sg_size);
|
|
|
|
/* Allocate a scatter/gather list for the DMA */
|
|
sglist = kzalloc(sizeof(struct ipr_sglist), GFP_KERNEL);
|
|
if (sglist == NULL) {
|
|
ipr_trace;
|
|
return NULL;
|
|
}
|
|
sglist->order = order;
|
|
sglist->scatterlist = sgl_alloc_order(buf_len, order, false, GFP_KERNEL,
|
|
&sglist->num_sg);
|
|
if (!sglist->scatterlist) {
|
|
kfree(sglist);
|
|
return NULL;
|
|
}
|
|
|
|
return sglist;
|
|
}
|
|
|
|
/**
|
|
* ipr_free_ucode_buffer - Frees a microcode download buffer
|
|
* @p_dnld: scatter/gather list pointer
|
|
*
|
|
* Free a DMA'able ucode download buffer previously allocated with
|
|
* ipr_alloc_ucode_buffer
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_free_ucode_buffer(struct ipr_sglist *sglist)
|
|
{
|
|
sgl_free_order(sglist->scatterlist, sglist->order);
|
|
kfree(sglist);
|
|
}
|
|
|
|
/**
|
|
* ipr_copy_ucode_buffer - Copy user buffer to kernel buffer
|
|
* @sglist: scatter/gather list pointer
|
|
* @buffer: buffer pointer
|
|
* @len: buffer length
|
|
*
|
|
* Copy a microcode image from a user buffer into a buffer allocated by
|
|
* ipr_alloc_ucode_buffer
|
|
*
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_copy_ucode_buffer(struct ipr_sglist *sglist,
|
|
u8 *buffer, u32 len)
|
|
{
|
|
int bsize_elem, i, result = 0;
|
|
struct scatterlist *scatterlist;
|
|
void *kaddr;
|
|
|
|
/* Determine the actual number of bytes per element */
|
|
bsize_elem = PAGE_SIZE * (1 << sglist->order);
|
|
|
|
scatterlist = sglist->scatterlist;
|
|
|
|
for (i = 0; i < (len / bsize_elem); i++, buffer += bsize_elem) {
|
|
struct page *page = sg_page(&scatterlist[i]);
|
|
|
|
kaddr = kmap(page);
|
|
memcpy(kaddr, buffer, bsize_elem);
|
|
kunmap(page);
|
|
|
|
scatterlist[i].length = bsize_elem;
|
|
|
|
if (result != 0) {
|
|
ipr_trace;
|
|
return result;
|
|
}
|
|
}
|
|
|
|
if (len % bsize_elem) {
|
|
struct page *page = sg_page(&scatterlist[i]);
|
|
|
|
kaddr = kmap(page);
|
|
memcpy(kaddr, buffer, len % bsize_elem);
|
|
kunmap(page);
|
|
|
|
scatterlist[i].length = len % bsize_elem;
|
|
}
|
|
|
|
sglist->buffer_len = len;
|
|
return result;
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ucode_ioadl64 - Build a microcode download IOADL
|
|
* @ipr_cmd: ipr command struct
|
|
* @sglist: scatter/gather list
|
|
*
|
|
* Builds a microcode download IOA data list (IOADL).
|
|
*
|
|
**/
|
|
static void ipr_build_ucode_ioadl64(struct ipr_cmnd *ipr_cmd,
|
|
struct ipr_sglist *sglist)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
|
|
struct scatterlist *scatterlist = sglist->scatterlist;
|
|
int i;
|
|
|
|
ipr_cmd->dma_use_sg = sglist->num_dma_sg;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
|
|
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
|
|
for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
|
|
ioadl64[i].flags = cpu_to_be32(IPR_IOADL_FLAGS_WRITE);
|
|
ioadl64[i].data_len = cpu_to_be32(sg_dma_len(&scatterlist[i]));
|
|
ioadl64[i].address = cpu_to_be64(sg_dma_address(&scatterlist[i]));
|
|
}
|
|
|
|
ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ucode_ioadl - Build a microcode download IOADL
|
|
* @ipr_cmd: ipr command struct
|
|
* @sglist: scatter/gather list
|
|
*
|
|
* Builds a microcode download IOA data list (IOADL).
|
|
*
|
|
**/
|
|
static void ipr_build_ucode_ioadl(struct ipr_cmnd *ipr_cmd,
|
|
struct ipr_sglist *sglist)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
|
|
struct scatterlist *scatterlist = sglist->scatterlist;
|
|
int i;
|
|
|
|
ipr_cmd->dma_use_sg = sglist->num_dma_sg;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->data_transfer_length = cpu_to_be32(sglist->buffer_len);
|
|
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
|
|
|
|
for (i = 0; i < ipr_cmd->dma_use_sg; i++) {
|
|
ioadl[i].flags_and_data_len =
|
|
cpu_to_be32(IPR_IOADL_FLAGS_WRITE | sg_dma_len(&scatterlist[i]));
|
|
ioadl[i].address =
|
|
cpu_to_be32(sg_dma_address(&scatterlist[i]));
|
|
}
|
|
|
|
ioadl[i-1].flags_and_data_len |=
|
|
cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_update_ioa_ucode - Update IOA's microcode
|
|
* @ioa_cfg: ioa config struct
|
|
* @sglist: scatter/gather list
|
|
*
|
|
* Initiate an adapter reset to update the IOA's microcode
|
|
*
|
|
* Return value:
|
|
* 0 on success / -EIO on failure
|
|
**/
|
|
static int ipr_update_ioa_ucode(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_sglist *sglist)
|
|
{
|
|
unsigned long lock_flags;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
if (ioa_cfg->ucode_sglist) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Microcode download already in progress\n");
|
|
return -EIO;
|
|
}
|
|
|
|
sglist->num_dma_sg = dma_map_sg(&ioa_cfg->pdev->dev,
|
|
sglist->scatterlist, sglist->num_sg,
|
|
DMA_TO_DEVICE);
|
|
|
|
if (!sglist->num_dma_sg) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Failed to map microcode download buffer!\n");
|
|
return -EIO;
|
|
}
|
|
|
|
ioa_cfg->ucode_sglist = sglist;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NORMAL);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ioa_cfg->ucode_sglist = NULL;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_store_update_fw - Update the firmware on the adapter
|
|
* @class_dev: device struct
|
|
* @buf: buffer
|
|
* @count: buffer size
|
|
*
|
|
* This function will update the firmware on the adapter.
|
|
*
|
|
* Return value:
|
|
* count on success / other on failure
|
|
**/
|
|
static ssize_t ipr_store_update_fw(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
struct ipr_ucode_image_header *image_hdr;
|
|
const struct firmware *fw_entry;
|
|
struct ipr_sglist *sglist;
|
|
char fname[100];
|
|
char *src;
|
|
char *endline;
|
|
int result, dnld_size;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
snprintf(fname, sizeof(fname), "%s", buf);
|
|
|
|
endline = strchr(fname, '\n');
|
|
if (endline)
|
|
*endline = '\0';
|
|
|
|
if (request_firmware(&fw_entry, fname, &ioa_cfg->pdev->dev)) {
|
|
dev_err(&ioa_cfg->pdev->dev, "Firmware file %s not found\n", fname);
|
|
return -EIO;
|
|
}
|
|
|
|
image_hdr = (struct ipr_ucode_image_header *)fw_entry->data;
|
|
|
|
src = (u8 *)image_hdr + be32_to_cpu(image_hdr->header_length);
|
|
dnld_size = fw_entry->size - be32_to_cpu(image_hdr->header_length);
|
|
sglist = ipr_alloc_ucode_buffer(dnld_size);
|
|
|
|
if (!sglist) {
|
|
dev_err(&ioa_cfg->pdev->dev, "Microcode buffer allocation failed\n");
|
|
release_firmware(fw_entry);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
result = ipr_copy_ucode_buffer(sglist, src, dnld_size);
|
|
|
|
if (result) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Microcode buffer copy to DMA buffer failed\n");
|
|
goto out;
|
|
}
|
|
|
|
ipr_info("Updating microcode, please be patient. This may take up to 30 minutes.\n");
|
|
|
|
result = ipr_update_ioa_ucode(ioa_cfg, sglist);
|
|
|
|
if (!result)
|
|
result = count;
|
|
out:
|
|
ipr_free_ucode_buffer(sglist);
|
|
release_firmware(fw_entry);
|
|
return result;
|
|
}
|
|
|
|
static struct device_attribute ipr_update_fw_attr = {
|
|
.attr = {
|
|
.name = "update_fw",
|
|
.mode = S_IWUSR,
|
|
},
|
|
.store = ipr_store_update_fw
|
|
};
|
|
|
|
/**
|
|
* ipr_show_fw_type - Show the adapter's firmware type.
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_fw_type(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct Scsi_Host *shost = class_to_shost(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
unsigned long lock_flags = 0;
|
|
int len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
len = snprintf(buf, PAGE_SIZE, "%d\n", ioa_cfg->sis64);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_ioa_fw_type_attr = {
|
|
.attr = {
|
|
.name = "fw_type",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.show = ipr_show_fw_type
|
|
};
|
|
|
|
static ssize_t ipr_read_async_err_log(struct file *filep, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr, char *buf,
|
|
loff_t off, size_t count)
|
|
{
|
|
struct device *cdev = container_of(kobj, struct device, kobj);
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
struct ipr_hostrcb *hostrcb;
|
|
unsigned long lock_flags = 0;
|
|
int ret;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
|
|
struct ipr_hostrcb, queue);
|
|
if (!hostrcb) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return 0;
|
|
}
|
|
ret = memory_read_from_buffer(buf, count, &off, &hostrcb->hcam,
|
|
sizeof(hostrcb->hcam));
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return ret;
|
|
}
|
|
|
|
static ssize_t ipr_next_async_err_log(struct file *filep, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr, char *buf,
|
|
loff_t off, size_t count)
|
|
{
|
|
struct device *cdev = container_of(kobj, struct device, kobj);
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
struct ipr_hostrcb *hostrcb;
|
|
unsigned long lock_flags = 0;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
hostrcb = list_first_entry_or_null(&ioa_cfg->hostrcb_report_q,
|
|
struct ipr_hostrcb, queue);
|
|
if (!hostrcb) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return count;
|
|
}
|
|
|
|
/* Reclaim hostrcb before exit */
|
|
list_move_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return count;
|
|
}
|
|
|
|
static struct bin_attribute ipr_ioa_async_err_log = {
|
|
.attr = {
|
|
.name = "async_err_log",
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
},
|
|
.size = 0,
|
|
.read = ipr_read_async_err_log,
|
|
.write = ipr_next_async_err_log
|
|
};
|
|
|
|
static struct device_attribute *ipr_ioa_attrs[] = {
|
|
&ipr_fw_version_attr,
|
|
&ipr_log_level_attr,
|
|
&ipr_diagnostics_attr,
|
|
&ipr_ioa_state_attr,
|
|
&ipr_ioa_reset_attr,
|
|
&ipr_update_fw_attr,
|
|
&ipr_ioa_fw_type_attr,
|
|
&ipr_iopoll_weight_attr,
|
|
NULL,
|
|
};
|
|
|
|
#ifdef CONFIG_SCSI_IPR_DUMP
|
|
/**
|
|
* ipr_read_dump - Dump the adapter
|
|
* @filp: open sysfs file
|
|
* @kobj: kobject struct
|
|
* @bin_attr: bin_attribute struct
|
|
* @buf: buffer
|
|
* @off: offset
|
|
* @count: buffer size
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_read_dump(struct file *filp, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr,
|
|
char *buf, loff_t off, size_t count)
|
|
{
|
|
struct device *cdev = container_of(kobj, struct device, kobj);
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
struct ipr_dump *dump;
|
|
unsigned long lock_flags = 0;
|
|
char *src;
|
|
int len, sdt_end;
|
|
size_t rc = count;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
dump = ioa_cfg->dump;
|
|
|
|
if (ioa_cfg->sdt_state != DUMP_OBTAINED || !dump) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return 0;
|
|
}
|
|
kref_get(&dump->kref);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (off > dump->driver_dump.hdr.len) {
|
|
kref_put(&dump->kref, ipr_release_dump);
|
|
return 0;
|
|
}
|
|
|
|
if (off + count > dump->driver_dump.hdr.len) {
|
|
count = dump->driver_dump.hdr.len - off;
|
|
rc = count;
|
|
}
|
|
|
|
if (count && off < sizeof(dump->driver_dump)) {
|
|
if (off + count > sizeof(dump->driver_dump))
|
|
len = sizeof(dump->driver_dump) - off;
|
|
else
|
|
len = count;
|
|
src = (u8 *)&dump->driver_dump + off;
|
|
memcpy(buf, src, len);
|
|
buf += len;
|
|
off += len;
|
|
count -= len;
|
|
}
|
|
|
|
off -= sizeof(dump->driver_dump);
|
|
|
|
if (ioa_cfg->sis64)
|
|
sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
|
|
(be32_to_cpu(dump->ioa_dump.sdt.hdr.num_entries_used) *
|
|
sizeof(struct ipr_sdt_entry));
|
|
else
|
|
sdt_end = offsetof(struct ipr_ioa_dump, sdt.entry) +
|
|
(IPR_FMT2_NUM_SDT_ENTRIES * sizeof(struct ipr_sdt_entry));
|
|
|
|
if (count && off < sdt_end) {
|
|
if (off + count > sdt_end)
|
|
len = sdt_end - off;
|
|
else
|
|
len = count;
|
|
src = (u8 *)&dump->ioa_dump + off;
|
|
memcpy(buf, src, len);
|
|
buf += len;
|
|
off += len;
|
|
count -= len;
|
|
}
|
|
|
|
off -= sdt_end;
|
|
|
|
while (count) {
|
|
if ((off & PAGE_MASK) != ((off + count) & PAGE_MASK))
|
|
len = PAGE_ALIGN(off) - off;
|
|
else
|
|
len = count;
|
|
src = (u8 *)dump->ioa_dump.ioa_data[(off & PAGE_MASK) >> PAGE_SHIFT];
|
|
src += off & ~PAGE_MASK;
|
|
memcpy(buf, src, len);
|
|
buf += len;
|
|
off += len;
|
|
count -= len;
|
|
}
|
|
|
|
kref_put(&dump->kref, ipr_release_dump);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_alloc_dump - Prepare for adapter dump
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_alloc_dump(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_dump *dump;
|
|
__be32 **ioa_data;
|
|
unsigned long lock_flags = 0;
|
|
|
|
dump = kzalloc(sizeof(struct ipr_dump), GFP_KERNEL);
|
|
|
|
if (!dump) {
|
|
ipr_err("Dump memory allocation failed\n");
|
|
return -ENOMEM;
|
|
}
|
|
|
|
if (ioa_cfg->sis64)
|
|
ioa_data = vmalloc(array_size(IPR_FMT3_MAX_NUM_DUMP_PAGES,
|
|
sizeof(__be32 *)));
|
|
else
|
|
ioa_data = vmalloc(array_size(IPR_FMT2_MAX_NUM_DUMP_PAGES,
|
|
sizeof(__be32 *)));
|
|
|
|
if (!ioa_data) {
|
|
ipr_err("Dump memory allocation failed\n");
|
|
kfree(dump);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
dump->ioa_dump.ioa_data = ioa_data;
|
|
|
|
kref_init(&dump->kref);
|
|
dump->ioa_cfg = ioa_cfg;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (INACTIVE != ioa_cfg->sdt_state) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
vfree(dump->ioa_dump.ioa_data);
|
|
kfree(dump);
|
|
return 0;
|
|
}
|
|
|
|
ioa_cfg->dump = dump;
|
|
ioa_cfg->sdt_state = WAIT_FOR_DUMP;
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead && !ioa_cfg->dump_taken) {
|
|
ioa_cfg->dump_taken = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_free_dump - Free adapter dump memory
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_dump *dump;
|
|
unsigned long lock_flags = 0;
|
|
|
|
ENTER;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
dump = ioa_cfg->dump;
|
|
if (!dump) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return 0;
|
|
}
|
|
|
|
ioa_cfg->dump = NULL;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
kref_put(&dump->kref, ipr_release_dump);
|
|
|
|
LEAVE;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_write_dump - Setup dump state of adapter
|
|
* @filp: open sysfs file
|
|
* @kobj: kobject struct
|
|
* @bin_attr: bin_attribute struct
|
|
* @buf: buffer
|
|
* @off: offset
|
|
* @count: buffer size
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_write_dump(struct file *filp, struct kobject *kobj,
|
|
struct bin_attribute *bin_attr,
|
|
char *buf, loff_t off, size_t count)
|
|
{
|
|
struct device *cdev = container_of(kobj, struct device, kobj);
|
|
struct Scsi_Host *shost = class_to_shost(cdev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
int rc;
|
|
|
|
if (!capable(CAP_SYS_ADMIN))
|
|
return -EACCES;
|
|
|
|
if (buf[0] == '1')
|
|
rc = ipr_alloc_dump(ioa_cfg);
|
|
else if (buf[0] == '0')
|
|
rc = ipr_free_dump(ioa_cfg);
|
|
else
|
|
return -EINVAL;
|
|
|
|
if (rc)
|
|
return rc;
|
|
else
|
|
return count;
|
|
}
|
|
|
|
static struct bin_attribute ipr_dump_attr = {
|
|
.attr = {
|
|
.name = "dump",
|
|
.mode = S_IRUSR | S_IWUSR,
|
|
},
|
|
.size = 0,
|
|
.read = ipr_read_dump,
|
|
.write = ipr_write_dump
|
|
};
|
|
#else
|
|
static int ipr_free_dump(struct ipr_ioa_cfg *ioa_cfg) { return 0; };
|
|
#endif
|
|
|
|
/**
|
|
* ipr_change_queue_depth - Change the device's queue depth
|
|
* @sdev: scsi device struct
|
|
* @qdepth: depth to set
|
|
* @reason: calling context
|
|
*
|
|
* Return value:
|
|
* actual depth set
|
|
**/
|
|
static int ipr_change_queue_depth(struct scsi_device *sdev, int qdepth)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
|
|
if (res && ipr_is_gata(res) && qdepth > IPR_MAX_CMD_PER_ATA_LUN)
|
|
qdepth = IPR_MAX_CMD_PER_ATA_LUN;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
scsi_change_queue_depth(sdev, qdepth);
|
|
return sdev->queue_depth;
|
|
}
|
|
|
|
/**
|
|
* ipr_show_adapter_handle - Show the adapter's resource handle for this device
|
|
* @dev: device struct
|
|
* @attr: device attribute structure
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_adapter_handle(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len = -ENXIO;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res)
|
|
len = snprintf(buf, PAGE_SIZE, "%08X\n", res->res_handle);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_adapter_handle_attr = {
|
|
.attr = {
|
|
.name = "adapter_handle",
|
|
.mode = S_IRUSR,
|
|
},
|
|
.show = ipr_show_adapter_handle
|
|
};
|
|
|
|
/**
|
|
* ipr_show_resource_path - Show the resource path or the resource address for
|
|
* this device.
|
|
* @dev: device struct
|
|
* @attr: device attribute structure
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_resource_path(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len = -ENXIO;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res && ioa_cfg->sis64)
|
|
len = snprintf(buf, PAGE_SIZE, "%s\n",
|
|
__ipr_format_res_path(res->res_path, buffer,
|
|
sizeof(buffer)));
|
|
else if (res)
|
|
len = snprintf(buf, PAGE_SIZE, "%d:%d:%d:%d\n", ioa_cfg->host->host_no,
|
|
res->bus, res->target, res->lun);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_resource_path_attr = {
|
|
.attr = {
|
|
.name = "resource_path",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.show = ipr_show_resource_path
|
|
};
|
|
|
|
/**
|
|
* ipr_show_device_id - Show the device_id for this device.
|
|
* @dev: device struct
|
|
* @attr: device attribute structure
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_device_id(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len = -ENXIO;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res && ioa_cfg->sis64)
|
|
len = snprintf(buf, PAGE_SIZE, "0x%llx\n", be64_to_cpu(res->dev_id));
|
|
else if (res)
|
|
len = snprintf(buf, PAGE_SIZE, "0x%llx\n", res->lun_wwn);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_device_id_attr = {
|
|
.attr = {
|
|
.name = "device_id",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.show = ipr_show_device_id
|
|
};
|
|
|
|
/**
|
|
* ipr_show_resource_type - Show the resource type for this device.
|
|
* @dev: device struct
|
|
* @attr: device attribute structure
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_resource_type(struct device *dev, struct device_attribute *attr, char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len = -ENXIO;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
|
|
if (res)
|
|
len = snprintf(buf, PAGE_SIZE, "%x\n", res->type);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_resource_type_attr = {
|
|
.attr = {
|
|
.name = "resource_type",
|
|
.mode = S_IRUGO,
|
|
},
|
|
.show = ipr_show_resource_type
|
|
};
|
|
|
|
/**
|
|
* ipr_show_raw_mode - Show the adapter's raw mode
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_show_raw_mode(struct device *dev,
|
|
struct device_attribute *attr, char *buf)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res)
|
|
len = snprintf(buf, PAGE_SIZE, "%d\n", res->raw_mode);
|
|
else
|
|
len = -ENXIO;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
/**
|
|
* ipr_store_raw_mode - Change the adapter's raw mode
|
|
* @dev: class device struct
|
|
* @buf: buffer
|
|
*
|
|
* Return value:
|
|
* number of bytes printed to buffer
|
|
**/
|
|
static ssize_t ipr_store_raw_mode(struct device *dev,
|
|
struct device_attribute *attr,
|
|
const char *buf, size_t count)
|
|
{
|
|
struct scsi_device *sdev = to_scsi_device(dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
ssize_t len;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res) {
|
|
if (ipr_is_af_dasd_device(res)) {
|
|
res->raw_mode = simple_strtoul(buf, NULL, 10);
|
|
len = strlen(buf);
|
|
if (res->sdev)
|
|
sdev_printk(KERN_INFO, res->sdev, "raw mode is %s\n",
|
|
res->raw_mode ? "enabled" : "disabled");
|
|
} else
|
|
len = -EINVAL;
|
|
} else
|
|
len = -ENXIO;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return len;
|
|
}
|
|
|
|
static struct device_attribute ipr_raw_mode_attr = {
|
|
.attr = {
|
|
.name = "raw_mode",
|
|
.mode = S_IRUGO | S_IWUSR,
|
|
},
|
|
.show = ipr_show_raw_mode,
|
|
.store = ipr_store_raw_mode
|
|
};
|
|
|
|
static struct device_attribute *ipr_dev_attrs[] = {
|
|
&ipr_adapter_handle_attr,
|
|
&ipr_resource_path_attr,
|
|
&ipr_device_id_attr,
|
|
&ipr_resource_type_attr,
|
|
&ipr_raw_mode_attr,
|
|
NULL,
|
|
};
|
|
|
|
/**
|
|
* ipr_biosparam - Return the HSC mapping
|
|
* @sdev: scsi device struct
|
|
* @block_device: block device pointer
|
|
* @capacity: capacity of the device
|
|
* @parm: Array containing returned HSC values.
|
|
*
|
|
* This function generates the HSC parms that fdisk uses.
|
|
* We want to make sure we return something that places partitions
|
|
* on 4k boundaries for best performance with the IOA.
|
|
*
|
|
* Return value:
|
|
* 0 on success
|
|
**/
|
|
static int ipr_biosparam(struct scsi_device *sdev,
|
|
struct block_device *block_device,
|
|
sector_t capacity, int *parm)
|
|
{
|
|
int heads, sectors;
|
|
sector_t cylinders;
|
|
|
|
heads = 128;
|
|
sectors = 32;
|
|
|
|
cylinders = capacity;
|
|
sector_div(cylinders, (128 * 32));
|
|
|
|
/* return result */
|
|
parm[0] = heads;
|
|
parm[1] = sectors;
|
|
parm[2] = cylinders;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_find_starget - Find target based on bus/target.
|
|
* @starget: scsi target struct
|
|
*
|
|
* Return value:
|
|
* resource entry pointer if found / NULL if not found
|
|
**/
|
|
static struct ipr_resource_entry *ipr_find_starget(struct scsi_target *starget)
|
|
{
|
|
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if ((res->bus == starget->channel) &&
|
|
(res->target == starget->id)) {
|
|
return res;
|
|
}
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
static struct ata_port_info sata_port_info;
|
|
|
|
/**
|
|
* ipr_target_alloc - Prepare for commands to a SCSI target
|
|
* @starget: scsi target struct
|
|
*
|
|
* If the device is a SATA device, this function allocates an
|
|
* ATA port with libata, else it does nothing.
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-0 on failure
|
|
**/
|
|
static int ipr_target_alloc(struct scsi_target *starget)
|
|
{
|
|
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
|
|
struct ipr_sata_port *sata_port;
|
|
struct ata_port *ap;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = ipr_find_starget(starget);
|
|
starget->hostdata = NULL;
|
|
|
|
if (res && ipr_is_gata(res)) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
sata_port = kzalloc(sizeof(*sata_port), GFP_KERNEL);
|
|
if (!sata_port)
|
|
return -ENOMEM;
|
|
|
|
ap = ata_sas_port_alloc(&ioa_cfg->ata_host, &sata_port_info, shost);
|
|
if (ap) {
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
sata_port->ioa_cfg = ioa_cfg;
|
|
sata_port->ap = ap;
|
|
sata_port->res = res;
|
|
|
|
res->sata_port = sata_port;
|
|
ap->private_data = sata_port;
|
|
starget->hostdata = sata_port;
|
|
} else {
|
|
kfree(sata_port);
|
|
return -ENOMEM;
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_target_destroy - Destroy a SCSI target
|
|
* @starget: scsi target struct
|
|
*
|
|
* If the device was a SATA device, this function frees the libata
|
|
* ATA port, else it does nothing.
|
|
*
|
|
**/
|
|
static void ipr_target_destroy(struct scsi_target *starget)
|
|
{
|
|
struct ipr_sata_port *sata_port = starget->hostdata;
|
|
struct Scsi_Host *shost = dev_to_shost(&starget->dev);
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
if (!ipr_find_starget(starget)) {
|
|
if (starget->channel == IPR_ARRAY_VIRTUAL_BUS)
|
|
clear_bit(starget->id, ioa_cfg->array_ids);
|
|
else if (starget->channel == IPR_VSET_VIRTUAL_BUS)
|
|
clear_bit(starget->id, ioa_cfg->vset_ids);
|
|
else if (starget->channel == 0)
|
|
clear_bit(starget->id, ioa_cfg->target_ids);
|
|
}
|
|
}
|
|
|
|
if (sata_port) {
|
|
starget->hostdata = NULL;
|
|
ata_sas_port_destroy(sata_port->ap);
|
|
kfree(sata_port);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_find_sdev - Find device based on bus/target/lun.
|
|
* @sdev: scsi device struct
|
|
*
|
|
* Return value:
|
|
* resource entry pointer if found / NULL if not found
|
|
**/
|
|
static struct ipr_resource_entry *ipr_find_sdev(struct scsi_device *sdev)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if ((res->bus == sdev->channel) &&
|
|
(res->target == sdev->id) &&
|
|
(res->lun == sdev->lun))
|
|
return res;
|
|
}
|
|
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ipr_slave_destroy - Unconfigure a SCSI device
|
|
* @sdev: scsi device struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_slave_destroy(struct scsi_device *sdev)
|
|
{
|
|
struct ipr_resource_entry *res;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
unsigned long lock_flags = 0;
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = (struct ipr_resource_entry *) sdev->hostdata;
|
|
if (res) {
|
|
if (res->sata_port)
|
|
res->sata_port->ap->link.device[0].class = ATA_DEV_NONE;
|
|
sdev->hostdata = NULL;
|
|
res->sdev = NULL;
|
|
res->sata_port = NULL;
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_slave_configure - Configure a SCSI device
|
|
* @sdev: scsi device struct
|
|
*
|
|
* This function configures the specified scsi device.
|
|
*
|
|
* Return value:
|
|
* 0 on success
|
|
**/
|
|
static int ipr_slave_configure(struct scsi_device *sdev)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
struct ata_port *ap = NULL;
|
|
unsigned long lock_flags = 0;
|
|
char buffer[IPR_MAX_RES_PATH_LENGTH];
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
res = sdev->hostdata;
|
|
if (res) {
|
|
if (ipr_is_af_dasd_device(res))
|
|
sdev->type = TYPE_RAID;
|
|
if (ipr_is_af_dasd_device(res) || ipr_is_ioa_resource(res)) {
|
|
sdev->scsi_level = 4;
|
|
sdev->no_uld_attach = 1;
|
|
}
|
|
if (ipr_is_vset_device(res)) {
|
|
sdev->scsi_level = SCSI_SPC_3;
|
|
sdev->no_report_opcodes = 1;
|
|
blk_queue_rq_timeout(sdev->request_queue,
|
|
IPR_VSET_RW_TIMEOUT);
|
|
blk_queue_max_hw_sectors(sdev->request_queue, IPR_VSET_MAX_SECTORS);
|
|
}
|
|
if (ipr_is_gata(res) && res->sata_port)
|
|
ap = res->sata_port->ap;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (ap) {
|
|
scsi_change_queue_depth(sdev, IPR_MAX_CMD_PER_ATA_LUN);
|
|
ata_sas_slave_configure(sdev, ap);
|
|
}
|
|
|
|
if (ioa_cfg->sis64)
|
|
sdev_printk(KERN_INFO, sdev, "Resource path: %s\n",
|
|
ipr_format_res_path(ioa_cfg,
|
|
res->res_path, buffer, sizeof(buffer)));
|
|
return 0;
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_ata_slave_alloc - Prepare for commands to a SATA device
|
|
* @sdev: scsi device struct
|
|
*
|
|
* This function initializes an ATA port so that future commands
|
|
* sent through queuecommand will work.
|
|
*
|
|
* Return value:
|
|
* 0 on success
|
|
**/
|
|
static int ipr_ata_slave_alloc(struct scsi_device *sdev)
|
|
{
|
|
struct ipr_sata_port *sata_port = NULL;
|
|
int rc = -ENXIO;
|
|
|
|
ENTER;
|
|
if (sdev->sdev_target)
|
|
sata_port = sdev->sdev_target->hostdata;
|
|
if (sata_port) {
|
|
rc = ata_sas_port_init(sata_port->ap);
|
|
if (rc == 0)
|
|
rc = ata_sas_sync_probe(sata_port->ap);
|
|
}
|
|
|
|
if (rc)
|
|
ipr_slave_destroy(sdev);
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_slave_alloc - Prepare for commands to a device.
|
|
* @sdev: scsi device struct
|
|
*
|
|
* This function saves a pointer to the resource entry
|
|
* in the scsi device struct if the device exists. We
|
|
* can then use this pointer in ipr_queuecommand when
|
|
* handling new commands.
|
|
*
|
|
* Return value:
|
|
* 0 on success / -ENXIO if device does not exist
|
|
**/
|
|
static int ipr_slave_alloc(struct scsi_device *sdev)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) sdev->host->hostdata;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags;
|
|
int rc = -ENXIO;
|
|
|
|
sdev->hostdata = NULL;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
res = ipr_find_sdev(sdev);
|
|
if (res) {
|
|
res->sdev = sdev;
|
|
res->add_to_ml = 0;
|
|
res->in_erp = 0;
|
|
sdev->hostdata = res;
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
rc = 0;
|
|
if (ipr_is_gata(res)) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return ipr_ata_slave_alloc(sdev);
|
|
}
|
|
}
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_match_lun - Match function for specified LUN
|
|
* @ipr_cmd: ipr command struct
|
|
* @device: device to match (sdev)
|
|
*
|
|
* Returns:
|
|
* 1 if command matches sdev / 0 if command does not match sdev
|
|
**/
|
|
static int ipr_match_lun(struct ipr_cmnd *ipr_cmd, void *device)
|
|
{
|
|
if (ipr_cmd->scsi_cmd && ipr_cmd->scsi_cmd->device == device)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_cmnd_is_free - Check if a command is free or not
|
|
* @ipr_cmd ipr command struct
|
|
*
|
|
* Returns:
|
|
* true / false
|
|
**/
|
|
static bool ipr_cmnd_is_free(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_cmnd *loop_cmd;
|
|
|
|
list_for_each_entry(loop_cmd, &ipr_cmd->hrrq->hrrq_free_q, queue) {
|
|
if (loop_cmd == ipr_cmd)
|
|
return true;
|
|
}
|
|
|
|
return false;
|
|
}
|
|
|
|
/**
|
|
* ipr_match_res - Match function for specified resource entry
|
|
* @ipr_cmd: ipr command struct
|
|
* @resource: resource entry to match
|
|
*
|
|
* Returns:
|
|
* 1 if command matches sdev / 0 if command does not match sdev
|
|
**/
|
|
static int ipr_match_res(struct ipr_cmnd *ipr_cmd, void *resource)
|
|
{
|
|
struct ipr_resource_entry *res = resource;
|
|
|
|
if (res && ipr_cmd->ioarcb.res_handle == res->res_handle)
|
|
return 1;
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_wait_for_ops - Wait for matching commands to complete
|
|
* @ipr_cmd: ipr command struct
|
|
* @device: device to match (sdev)
|
|
* @match: match function to use
|
|
*
|
|
* Returns:
|
|
* SUCCESS / FAILED
|
|
**/
|
|
static int ipr_wait_for_ops(struct ipr_ioa_cfg *ioa_cfg, void *device,
|
|
int (*match)(struct ipr_cmnd *, void *))
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
int wait, i;
|
|
unsigned long flags;
|
|
struct ipr_hrr_queue *hrrq;
|
|
signed long timeout = IPR_ABORT_TASK_TIMEOUT;
|
|
DECLARE_COMPLETION_ONSTACK(comp);
|
|
|
|
ENTER;
|
|
do {
|
|
wait = 0;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock_irqsave(hrrq->lock, flags);
|
|
for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
|
|
ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
|
|
if (!ipr_cmnd_is_free(ipr_cmd)) {
|
|
if (match(ipr_cmd, device)) {
|
|
ipr_cmd->eh_comp = ∁
|
|
wait++;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(hrrq->lock, flags);
|
|
}
|
|
|
|
if (wait) {
|
|
timeout = wait_for_completion_timeout(&comp, timeout);
|
|
|
|
if (!timeout) {
|
|
wait = 0;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock_irqsave(hrrq->lock, flags);
|
|
for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
|
|
ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
|
|
if (!ipr_cmnd_is_free(ipr_cmd)) {
|
|
if (match(ipr_cmd, device)) {
|
|
ipr_cmd->eh_comp = NULL;
|
|
wait++;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock_irqrestore(hrrq->lock, flags);
|
|
}
|
|
|
|
if (wait)
|
|
dev_err(&ioa_cfg->pdev->dev, "Timed out waiting for aborted commands\n");
|
|
LEAVE;
|
|
return wait ? FAILED : SUCCESS;
|
|
}
|
|
}
|
|
} while (wait);
|
|
|
|
LEAVE;
|
|
return SUCCESS;
|
|
}
|
|
|
|
static int ipr_eh_host_reset(struct scsi_cmnd *cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
unsigned long lock_flags = 0;
|
|
int rc = SUCCESS;
|
|
|
|
ENTER;
|
|
ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (!ioa_cfg->in_reset_reload && !ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Adapter being reset as a result of error recovery.\n");
|
|
|
|
if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
|
|
ioa_cfg->sdt_state = GET_DUMP;
|
|
}
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
/* If we got hit with a host reset while we were already resetting
|
|
the adapter for some reason, and the reset failed. */
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
|
|
ipr_trace;
|
|
rc = FAILED;
|
|
}
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_device_reset - Reset the device
|
|
* @ioa_cfg: ioa config struct
|
|
* @res: resource entry struct
|
|
*
|
|
* This function issues a device reset to the affected device.
|
|
* If the device is a SCSI device, a LUN reset will be sent
|
|
* to the device first. If that does not work, a target reset
|
|
* will be sent. If the device is a SATA device, a PHY reset will
|
|
* be sent.
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static int ipr_device_reset(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_resource_entry *res)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioarcb *ioarcb;
|
|
struct ipr_cmd_pkt *cmd_pkt;
|
|
struct ipr_ioarcb_ata_regs *regs;
|
|
u32 ioasc;
|
|
|
|
ENTER;
|
|
ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
ioarcb = &ipr_cmd->ioarcb;
|
|
cmd_pkt = &ioarcb->cmd_pkt;
|
|
|
|
if (ipr_cmd->ioa_cfg->sis64) {
|
|
regs = &ipr_cmd->i.ata_ioadl.regs;
|
|
ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
|
|
} else
|
|
regs = &ioarcb->u.add_data.u.regs;
|
|
|
|
ioarcb->res_handle = res->res_handle;
|
|
cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
|
|
if (ipr_is_gata(res)) {
|
|
cmd_pkt->cdb[2] = IPR_ATA_PHY_RESET;
|
|
ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(regs->flags));
|
|
regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
|
|
}
|
|
|
|
ipr_send_blocking_cmd(ipr_cmd, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
|
|
ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
if (ipr_is_gata(res) && res->sata_port && ioasc != IPR_IOASC_IOA_WAS_RESET) {
|
|
if (ipr_cmd->ioa_cfg->sis64)
|
|
memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
|
|
sizeof(struct ipr_ioasa_gata));
|
|
else
|
|
memcpy(&res->sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
|
|
sizeof(struct ipr_ioasa_gata));
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_IOASC_SENSE_KEY(ioasc) ? -EIO : 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_sata_reset - Reset the SATA port
|
|
* @link: SATA link to reset
|
|
* @classes: class of the attached device
|
|
*
|
|
* This function issues a SATA phy reset to the affected ATA link.
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static int ipr_sata_reset(struct ata_link *link, unsigned int *classes,
|
|
unsigned long deadline)
|
|
{
|
|
struct ipr_sata_port *sata_port = link->ap->private_data;
|
|
struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
unsigned long lock_flags = 0;
|
|
int rc = -ENXIO, ret;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
res = sata_port->res;
|
|
if (res) {
|
|
rc = ipr_device_reset(ioa_cfg, res);
|
|
*classes = res->ata_class;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
ret = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
|
|
if (ret != SUCCESS) {
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_ABBREV);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
}
|
|
} else
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_eh_dev_reset - Reset the device
|
|
* @scsi_cmd: scsi command struct
|
|
*
|
|
* This function issues a device reset to the affected device.
|
|
* A LUN reset will be sent to the device first. If that does
|
|
* not work, a target reset will be sent.
|
|
*
|
|
* Return value:
|
|
* SUCCESS / FAILED
|
|
**/
|
|
static int __ipr_eh_dev_reset(struct scsi_cmnd *scsi_cmd)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
struct ata_port *ap;
|
|
int rc = 0, i;
|
|
struct ipr_hrr_queue *hrrq;
|
|
|
|
ENTER;
|
|
ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
|
|
res = scsi_cmd->device->hostdata;
|
|
|
|
/*
|
|
* If we are currently going through reset/reload, return failed. This will force the
|
|
* mid-layer to call ipr_eh_host_reset, which will then go to sleep and wait for the
|
|
* reset to complete
|
|
*/
|
|
if (ioa_cfg->in_reset_reload)
|
|
return FAILED;
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
|
|
return FAILED;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
|
|
ipr_cmd = ioa_cfg->ipr_cmnd_list[i];
|
|
|
|
if (ipr_cmd->ioarcb.res_handle == res->res_handle) {
|
|
if (!ipr_cmd->qc)
|
|
continue;
|
|
if (ipr_cmnd_is_free(ipr_cmd))
|
|
continue;
|
|
|
|
ipr_cmd->done = ipr_sata_eh_done;
|
|
if (!(ipr_cmd->qc->flags & ATA_QCFLAG_FAILED)) {
|
|
ipr_cmd->qc->err_mask |= AC_ERR_TIMEOUT;
|
|
ipr_cmd->qc->flags |= ATA_QCFLAG_FAILED;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock(&hrrq->_lock);
|
|
}
|
|
res->resetting_device = 1;
|
|
scmd_printk(KERN_ERR, scsi_cmd, "Resetting device\n");
|
|
|
|
if (ipr_is_gata(res) && res->sata_port) {
|
|
ap = res->sata_port->ap;
|
|
spin_unlock_irq(scsi_cmd->device->host->host_lock);
|
|
ata_std_error_handler(ap);
|
|
spin_lock_irq(scsi_cmd->device->host->host_lock);
|
|
} else
|
|
rc = ipr_device_reset(ioa_cfg, res);
|
|
res->resetting_device = 0;
|
|
res->reset_occurred = 1;
|
|
|
|
LEAVE;
|
|
return rc ? FAILED : SUCCESS;
|
|
}
|
|
|
|
static int ipr_eh_dev_reset(struct scsi_cmnd *cmd)
|
|
{
|
|
int rc;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *) cmd->device->host->hostdata;
|
|
res = cmd->device->hostdata;
|
|
|
|
if (!res)
|
|
return FAILED;
|
|
|
|
spin_lock_irq(cmd->device->host->host_lock);
|
|
rc = __ipr_eh_dev_reset(cmd);
|
|
spin_unlock_irq(cmd->device->host->host_lock);
|
|
|
|
if (rc == SUCCESS) {
|
|
if (ipr_is_gata(res) && res->sata_port)
|
|
rc = ipr_wait_for_ops(ioa_cfg, res, ipr_match_res);
|
|
else
|
|
rc = ipr_wait_for_ops(ioa_cfg, cmd->device, ipr_match_lun);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_bus_reset_done - Op done function for bus reset.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is the op done function for a bus reset
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_bus_reset_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
|
|
ENTER;
|
|
if (!ioa_cfg->sis64)
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (res->res_handle == ipr_cmd->ioarcb.res_handle) {
|
|
scsi_report_bus_reset(ioa_cfg->host, res->bus);
|
|
break;
|
|
}
|
|
}
|
|
|
|
/*
|
|
* If abort has not completed, indicate the reset has, else call the
|
|
* abort's done function to wake the sleeping eh thread
|
|
*/
|
|
if (ipr_cmd->sibling->sibling)
|
|
ipr_cmd->sibling->sibling = NULL;
|
|
else
|
|
ipr_cmd->sibling->done(ipr_cmd->sibling);
|
|
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_abort_timeout - An abort task has timed out
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function handles when an abort task times out. If this
|
|
* happens we issue a bus reset since we have resources tied
|
|
* up that must be freed before returning to the midlayer.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_abort_timeout(struct timer_list *t)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
|
|
struct ipr_cmnd *reset_cmd;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_cmd_pkt *cmd_pkt;
|
|
unsigned long lock_flags = 0;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ipr_cmd->completion.done || ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return;
|
|
}
|
|
|
|
sdev_printk(KERN_ERR, ipr_cmd->u.sdev, "Abort timed out. Resetting bus.\n");
|
|
reset_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
ipr_cmd->sibling = reset_cmd;
|
|
reset_cmd->sibling = ipr_cmd;
|
|
reset_cmd->ioarcb.res_handle = ipr_cmd->ioarcb.res_handle;
|
|
cmd_pkt = &reset_cmd->ioarcb.cmd_pkt;
|
|
cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt->cdb[0] = IPR_RESET_DEVICE;
|
|
cmd_pkt->cdb[2] = IPR_RESET_TYPE_SELECT | IPR_BUS_RESET;
|
|
|
|
ipr_do_req(reset_cmd, ipr_bus_reset_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_cancel_op - Cancel specified op
|
|
* @scsi_cmd: scsi command struct
|
|
*
|
|
* This function cancels specified op.
|
|
*
|
|
* Return value:
|
|
* SUCCESS / FAILED
|
|
**/
|
|
static int ipr_cancel_op(struct scsi_cmnd *scsi_cmd)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
struct ipr_cmd_pkt *cmd_pkt;
|
|
u32 ioasc, int_reg;
|
|
int i, op_found = 0;
|
|
struct ipr_hrr_queue *hrrq;
|
|
|
|
ENTER;
|
|
ioa_cfg = (struct ipr_ioa_cfg *)scsi_cmd->device->host->hostdata;
|
|
res = scsi_cmd->device->hostdata;
|
|
|
|
/* If we are currently going through reset/reload, return failed.
|
|
* This will force the mid-layer to call ipr_eh_host_reset,
|
|
* which will then go to sleep and wait for the reset to complete
|
|
*/
|
|
if (ioa_cfg->in_reset_reload ||
|
|
ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
|
|
return FAILED;
|
|
if (!res)
|
|
return FAILED;
|
|
|
|
/*
|
|
* If we are aborting a timed out op, chances are that the timeout was caused
|
|
* by a still not detected EEH error. In such cases, reading a register will
|
|
* trigger the EEH recovery infrastructure.
|
|
*/
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
|
|
if (!ipr_is_gscsi(res))
|
|
return FAILED;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
for (i = hrrq->min_cmd_id; i <= hrrq->max_cmd_id; i++) {
|
|
if (ioa_cfg->ipr_cmnd_list[i]->scsi_cmd == scsi_cmd) {
|
|
if (!ipr_cmnd_is_free(ioa_cfg->ipr_cmnd_list[i])) {
|
|
op_found = 1;
|
|
break;
|
|
}
|
|
}
|
|
}
|
|
spin_unlock(&hrrq->_lock);
|
|
}
|
|
|
|
if (!op_found)
|
|
return SUCCESS;
|
|
|
|
ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
ipr_cmd->ioarcb.res_handle = res->res_handle;
|
|
cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
|
|
cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
|
|
ipr_cmd->u.sdev = scsi_cmd->device;
|
|
|
|
scmd_printk(KERN_ERR, scsi_cmd, "Aborting command: %02X\n",
|
|
scsi_cmd->cmnd[0]);
|
|
ipr_send_blocking_cmd(ipr_cmd, ipr_abort_timeout, IPR_CANCEL_ALL_TIMEOUT);
|
|
ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
/*
|
|
* If the abort task timed out and we sent a bus reset, we will get
|
|
* one the following responses to the abort
|
|
*/
|
|
if (ioasc == IPR_IOASC_BUS_WAS_RESET || ioasc == IPR_IOASC_SYNC_REQUIRED) {
|
|
ioasc = 0;
|
|
ipr_trace;
|
|
}
|
|
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
|
|
LEAVE;
|
|
return IPR_IOASC_SENSE_KEY(ioasc) ? FAILED : SUCCESS;
|
|
}
|
|
|
|
/**
|
|
* ipr_eh_abort - Abort a single op
|
|
* @scsi_cmd: scsi command struct
|
|
*
|
|
* Return value:
|
|
* 0 if scan in progress / 1 if scan is complete
|
|
**/
|
|
static int ipr_scan_finished(struct Scsi_Host *shost, unsigned long elapsed_time)
|
|
{
|
|
unsigned long lock_flags;
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *) shost->hostdata;
|
|
int rc = 0;
|
|
|
|
spin_lock_irqsave(shost->host_lock, lock_flags);
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead || ioa_cfg->scan_done)
|
|
rc = 1;
|
|
if ((elapsed_time/HZ) > (ioa_cfg->transop_timeout * 2))
|
|
rc = 1;
|
|
spin_unlock_irqrestore(shost->host_lock, lock_flags);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_eh_host_reset - Reset the host adapter
|
|
* @scsi_cmd: scsi command struct
|
|
*
|
|
* Return value:
|
|
* SUCCESS / FAILED
|
|
**/
|
|
static int ipr_eh_abort(struct scsi_cmnd *scsi_cmd)
|
|
{
|
|
unsigned long flags;
|
|
int rc;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
|
|
ENTER;
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *) scsi_cmd->device->host->hostdata;
|
|
|
|
spin_lock_irqsave(scsi_cmd->device->host->host_lock, flags);
|
|
rc = ipr_cancel_op(scsi_cmd);
|
|
spin_unlock_irqrestore(scsi_cmd->device->host->host_lock, flags);
|
|
|
|
if (rc == SUCCESS)
|
|
rc = ipr_wait_for_ops(ioa_cfg, scsi_cmd->device, ipr_match_lun);
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_handle_other_interrupt - Handle "other" interrupts
|
|
* @ioa_cfg: ioa config struct
|
|
* @int_reg: interrupt register
|
|
*
|
|
* Return value:
|
|
* IRQ_NONE / IRQ_HANDLED
|
|
**/
|
|
static irqreturn_t ipr_handle_other_interrupt(struct ipr_ioa_cfg *ioa_cfg,
|
|
u32 int_reg)
|
|
{
|
|
irqreturn_t rc = IRQ_HANDLED;
|
|
u32 int_mask_reg;
|
|
|
|
int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
|
|
int_reg &= ~int_mask_reg;
|
|
|
|
/* If an interrupt on the adapter did not occur, ignore it.
|
|
* Or in the case of SIS 64, check for a stage change interrupt.
|
|
*/
|
|
if ((int_reg & IPR_PCII_OPER_INTERRUPTS) == 0) {
|
|
if (ioa_cfg->sis64) {
|
|
int_mask_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
|
|
if (int_reg & IPR_PCII_IPL_STAGE_CHANGE) {
|
|
|
|
/* clear stage change */
|
|
writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.clr_interrupt_reg);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg) & ~int_mask_reg;
|
|
list_del(&ioa_cfg->reset_cmd->queue);
|
|
del_timer(&ioa_cfg->reset_cmd->timer);
|
|
ipr_reset_ioa_job(ioa_cfg->reset_cmd);
|
|
return IRQ_HANDLED;
|
|
}
|
|
}
|
|
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
|
|
/* Mask the interrupt */
|
|
writel(IPR_PCII_IOA_TRANS_TO_OPER, ioa_cfg->regs.set_interrupt_mask_reg);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
|
|
list_del(&ioa_cfg->reset_cmd->queue);
|
|
del_timer(&ioa_cfg->reset_cmd->timer);
|
|
ipr_reset_ioa_job(ioa_cfg->reset_cmd);
|
|
} else if ((int_reg & IPR_PCII_HRRQ_UPDATED) == int_reg) {
|
|
if (ioa_cfg->clear_isr) {
|
|
if (ipr_debug && printk_ratelimit())
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Spurious interrupt detected. 0x%08X\n", int_reg);
|
|
writel(IPR_PCII_HRRQ_UPDATED, ioa_cfg->regs.clr_interrupt_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
return IRQ_NONE;
|
|
}
|
|
} else {
|
|
if (int_reg & IPR_PCII_IOA_UNIT_CHECKED)
|
|
ioa_cfg->ioa_unit_checked = 1;
|
|
else if (int_reg & IPR_PCII_NO_HOST_RRQ)
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"No Host RRQ. 0x%08X\n", int_reg);
|
|
else
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Permanent IOA failure. 0x%08X\n", int_reg);
|
|
|
|
if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
|
|
ioa_cfg->sdt_state = GET_DUMP;
|
|
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_isr_eh - Interrupt service routine error handler
|
|
* @ioa_cfg: ioa config struct
|
|
* @msg: message to log
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_isr_eh(struct ipr_ioa_cfg *ioa_cfg, char *msg, u16 number)
|
|
{
|
|
ioa_cfg->errors_logged++;
|
|
dev_err(&ioa_cfg->pdev->dev, "%s %d\n", msg, number);
|
|
|
|
if (WAIT_FOR_DUMP == ioa_cfg->sdt_state)
|
|
ioa_cfg->sdt_state = GET_DUMP;
|
|
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
}
|
|
|
|
static int ipr_process_hrrq(struct ipr_hrr_queue *hrr_queue, int budget,
|
|
struct list_head *doneq)
|
|
{
|
|
u32 ioasc;
|
|
u16 cmd_index;
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioa_cfg *ioa_cfg = hrr_queue->ioa_cfg;
|
|
int num_hrrq = 0;
|
|
|
|
/* If interrupts are disabled, ignore the interrupt */
|
|
if (!hrr_queue->allow_interrupts)
|
|
return 0;
|
|
|
|
while ((be32_to_cpu(*hrr_queue->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
|
|
hrr_queue->toggle_bit) {
|
|
|
|
cmd_index = (be32_to_cpu(*hrr_queue->hrrq_curr) &
|
|
IPR_HRRQ_REQ_RESP_HANDLE_MASK) >>
|
|
IPR_HRRQ_REQ_RESP_HANDLE_SHIFT;
|
|
|
|
if (unlikely(cmd_index > hrr_queue->max_cmd_id ||
|
|
cmd_index < hrr_queue->min_cmd_id)) {
|
|
ipr_isr_eh(ioa_cfg,
|
|
"Invalid response handle from IOA: ",
|
|
cmd_index);
|
|
break;
|
|
}
|
|
|
|
ipr_cmd = ioa_cfg->ipr_cmnd_list[cmd_index];
|
|
ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_FINISH, ioasc);
|
|
|
|
list_move_tail(&ipr_cmd->queue, doneq);
|
|
|
|
if (hrr_queue->hrrq_curr < hrr_queue->hrrq_end) {
|
|
hrr_queue->hrrq_curr++;
|
|
} else {
|
|
hrr_queue->hrrq_curr = hrr_queue->hrrq_start;
|
|
hrr_queue->toggle_bit ^= 1u;
|
|
}
|
|
num_hrrq++;
|
|
if (budget > 0 && num_hrrq >= budget)
|
|
break;
|
|
}
|
|
|
|
return num_hrrq;
|
|
}
|
|
|
|
static int ipr_iopoll(struct irq_poll *iop, int budget)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct ipr_hrr_queue *hrrq;
|
|
struct ipr_cmnd *ipr_cmd, *temp;
|
|
unsigned long hrrq_flags;
|
|
int completed_ops;
|
|
LIST_HEAD(doneq);
|
|
|
|
hrrq = container_of(iop, struct ipr_hrr_queue, iopoll);
|
|
ioa_cfg = hrrq->ioa_cfg;
|
|
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
completed_ops = ipr_process_hrrq(hrrq, budget, &doneq);
|
|
|
|
if (completed_ops < budget)
|
|
irq_poll_complete(iop);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
|
|
list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
|
|
list_del(&ipr_cmd->queue);
|
|
del_timer(&ipr_cmd->timer);
|
|
ipr_cmd->fast_done(ipr_cmd);
|
|
}
|
|
|
|
return completed_ops;
|
|
}
|
|
|
|
/**
|
|
* ipr_isr - Interrupt service routine
|
|
* @irq: irq number
|
|
* @devp: pointer to ioa config struct
|
|
*
|
|
* Return value:
|
|
* IRQ_NONE / IRQ_HANDLED
|
|
**/
|
|
static irqreturn_t ipr_isr(int irq, void *devp)
|
|
{
|
|
struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
|
|
struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
|
|
unsigned long hrrq_flags = 0;
|
|
u32 int_reg = 0;
|
|
int num_hrrq = 0;
|
|
int irq_none = 0;
|
|
struct ipr_cmnd *ipr_cmd, *temp;
|
|
irqreturn_t rc = IRQ_NONE;
|
|
LIST_HEAD(doneq);
|
|
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
/* If interrupts are disabled, ignore the interrupt */
|
|
if (!hrrq->allow_interrupts) {
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
while (1) {
|
|
if (ipr_process_hrrq(hrrq, -1, &doneq)) {
|
|
rc = IRQ_HANDLED;
|
|
|
|
if (!ioa_cfg->clear_isr)
|
|
break;
|
|
|
|
/* Clear the PCI interrupt */
|
|
num_hrrq = 0;
|
|
do {
|
|
writel(IPR_PCII_HRRQ_UPDATED,
|
|
ioa_cfg->regs.clr_interrupt_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
} while (int_reg & IPR_PCII_HRRQ_UPDATED &&
|
|
num_hrrq++ < IPR_MAX_HRRQ_RETRIES);
|
|
|
|
} else if (rc == IRQ_NONE && irq_none == 0) {
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
irq_none++;
|
|
} else if (num_hrrq == IPR_MAX_HRRQ_RETRIES &&
|
|
int_reg & IPR_PCII_HRRQ_UPDATED) {
|
|
ipr_isr_eh(ioa_cfg,
|
|
"Error clearing HRRQ: ", num_hrrq);
|
|
rc = IRQ_HANDLED;
|
|
break;
|
|
} else
|
|
break;
|
|
}
|
|
|
|
if (unlikely(rc == IRQ_NONE))
|
|
rc = ipr_handle_other_interrupt(ioa_cfg, int_reg);
|
|
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
|
|
list_del(&ipr_cmd->queue);
|
|
del_timer(&ipr_cmd->timer);
|
|
ipr_cmd->fast_done(ipr_cmd);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_isr_mhrrq - Interrupt service routine
|
|
* @irq: irq number
|
|
* @devp: pointer to ioa config struct
|
|
*
|
|
* Return value:
|
|
* IRQ_NONE / IRQ_HANDLED
|
|
**/
|
|
static irqreturn_t ipr_isr_mhrrq(int irq, void *devp)
|
|
{
|
|
struct ipr_hrr_queue *hrrq = (struct ipr_hrr_queue *)devp;
|
|
struct ipr_ioa_cfg *ioa_cfg = hrrq->ioa_cfg;
|
|
unsigned long hrrq_flags = 0;
|
|
struct ipr_cmnd *ipr_cmd, *temp;
|
|
irqreturn_t rc = IRQ_NONE;
|
|
LIST_HEAD(doneq);
|
|
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
|
|
/* If interrupts are disabled, ignore the interrupt */
|
|
if (!hrrq->allow_interrupts) {
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return IRQ_NONE;
|
|
}
|
|
|
|
if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
|
|
if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
|
|
hrrq->toggle_bit) {
|
|
irq_poll_sched(&hrrq->iopoll);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return IRQ_HANDLED;
|
|
}
|
|
} else {
|
|
if ((be32_to_cpu(*hrrq->hrrq_curr) & IPR_HRRQ_TOGGLE_BIT) ==
|
|
hrrq->toggle_bit)
|
|
|
|
if (ipr_process_hrrq(hrrq, -1, &doneq))
|
|
rc = IRQ_HANDLED;
|
|
}
|
|
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
|
|
list_for_each_entry_safe(ipr_cmd, temp, &doneq, queue) {
|
|
list_del(&ipr_cmd->queue);
|
|
del_timer(&ipr_cmd->timer);
|
|
ipr_cmd->fast_done(ipr_cmd);
|
|
}
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ioadl64 - Build a scatter/gather list and map the buffer
|
|
* @ioa_cfg: ioa config struct
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / -1 on failure
|
|
**/
|
|
static int ipr_build_ioadl64(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
int i, nseg;
|
|
struct scatterlist *sg;
|
|
u32 length;
|
|
u32 ioadl_flags = 0;
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ioadl64;
|
|
|
|
length = scsi_bufflen(scsi_cmd);
|
|
if (!length)
|
|
return 0;
|
|
|
|
nseg = scsi_dma_map(scsi_cmd);
|
|
if (nseg < 0) {
|
|
if (printk_ratelimit())
|
|
dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
ipr_cmd->dma_use_sg = nseg;
|
|
|
|
ioarcb->data_transfer_length = cpu_to_be32(length);
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
|
|
|
|
if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_WRITE;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
} else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE)
|
|
ioadl_flags = IPR_IOADL_FLAGS_READ;
|
|
|
|
scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
|
|
ioadl64[i].flags = cpu_to_be32(ioadl_flags);
|
|
ioadl64[i].data_len = cpu_to_be32(sg_dma_len(sg));
|
|
ioadl64[i].address = cpu_to_be64(sg_dma_address(sg));
|
|
}
|
|
|
|
ioadl64[i-1].flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ioadl - Build a scatter/gather list and map the buffer
|
|
* @ioa_cfg: ioa config struct
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / -1 on failure
|
|
**/
|
|
static int ipr_build_ioadl(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
int i, nseg;
|
|
struct scatterlist *sg;
|
|
u32 length;
|
|
u32 ioadl_flags = 0;
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
|
|
|
|
length = scsi_bufflen(scsi_cmd);
|
|
if (!length)
|
|
return 0;
|
|
|
|
nseg = scsi_dma_map(scsi_cmd);
|
|
if (nseg < 0) {
|
|
dev_err(&ioa_cfg->pdev->dev, "scsi_dma_map failed!\n");
|
|
return -1;
|
|
}
|
|
|
|
ipr_cmd->dma_use_sg = nseg;
|
|
|
|
if (scsi_cmd->sc_data_direction == DMA_TO_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_WRITE;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->data_transfer_length = cpu_to_be32(length);
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
|
|
} else if (scsi_cmd->sc_data_direction == DMA_FROM_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_READ;
|
|
ioarcb->read_data_transfer_length = cpu_to_be32(length);
|
|
ioarcb->read_ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
|
|
}
|
|
|
|
if (ipr_cmd->dma_use_sg <= ARRAY_SIZE(ioarcb->u.add_data.u.ioadl)) {
|
|
ioadl = ioarcb->u.add_data.u.ioadl;
|
|
ioarcb->write_ioadl_addr = cpu_to_be32((ipr_cmd->dma_addr) +
|
|
offsetof(struct ipr_ioarcb, u.add_data));
|
|
ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
|
|
}
|
|
|
|
scsi_for_each_sg(scsi_cmd, sg, ipr_cmd->dma_use_sg, i) {
|
|
ioadl[i].flags_and_data_len =
|
|
cpu_to_be32(ioadl_flags | sg_dma_len(sg));
|
|
ioadl[i].address = cpu_to_be32(sg_dma_address(sg));
|
|
}
|
|
|
|
ioadl[i-1].flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* __ipr_erp_done - Process completion of ERP for a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function copies the sense buffer into the scsi_cmd
|
|
* struct and pushes the scsi_done function.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void __ipr_erp_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
|
|
scsi_cmd->result |= (DID_ERROR << 16);
|
|
scmd_printk(KERN_ERR, scsi_cmd,
|
|
"Request Sense failed with IOASC: 0x%08X\n", ioasc);
|
|
} else {
|
|
memcpy(scsi_cmd->sense_buffer, ipr_cmd->sense_buffer,
|
|
SCSI_SENSE_BUFFERSIZE);
|
|
}
|
|
|
|
if (res) {
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
res->in_erp = 0;
|
|
}
|
|
scsi_dma_unmap(ipr_cmd->scsi_cmd);
|
|
scsi_cmd->scsi_done(scsi_cmd);
|
|
if (ipr_cmd->eh_comp)
|
|
complete(ipr_cmd->eh_comp);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_erp_done - Process completion of ERP for a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function copies the sense buffer into the scsi_cmd
|
|
* struct and pushes the scsi_done function.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_erp_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
|
|
unsigned long hrrq_flags;
|
|
|
|
spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
|
|
__ipr_erp_done(ipr_cmd);
|
|
spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_reinit_ipr_cmnd_for_erp - Re-initialize a cmnd block to be used for ERP
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_reinit_ipr_cmnd_for_erp(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
|
|
dma_addr_t dma_addr = ipr_cmd->dma_addr;
|
|
|
|
memset(&ioarcb->cmd_pkt, 0, sizeof(struct ipr_cmd_pkt));
|
|
ioarcb->data_transfer_length = 0;
|
|
ioarcb->read_data_transfer_length = 0;
|
|
ioarcb->ioadl_len = 0;
|
|
ioarcb->read_ioadl_len = 0;
|
|
ioasa->hdr.ioasc = 0;
|
|
ioasa->hdr.residual_data_len = 0;
|
|
|
|
if (ipr_cmd->ioa_cfg->sis64)
|
|
ioarcb->u.sis64_addr_data.data_ioadl_addr =
|
|
cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
|
|
else {
|
|
ioarcb->write_ioadl_addr =
|
|
cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
|
|
ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* __ipr_erp_request_sense - Send request sense to a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a request sense to a device as a result
|
|
* of a check condition.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void __ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_cmd_pkt *cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (IPR_IOASC_SENSE_KEY(ioasc) > 0) {
|
|
__ipr_erp_done(ipr_cmd);
|
|
return;
|
|
}
|
|
|
|
ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
|
|
|
|
cmd_pkt->request_type = IPR_RQTYPE_SCSICDB;
|
|
cmd_pkt->cdb[0] = REQUEST_SENSE;
|
|
cmd_pkt->cdb[4] = SCSI_SENSE_BUFFERSIZE;
|
|
cmd_pkt->flags_hi |= IPR_FLAGS_HI_SYNC_OVERRIDE;
|
|
cmd_pkt->flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
|
|
cmd_pkt->timeout = cpu_to_be16(IPR_REQUEST_SENSE_TIMEOUT / HZ);
|
|
|
|
ipr_init_ioadl(ipr_cmd, ipr_cmd->sense_buffer_dma,
|
|
SCSI_SENSE_BUFFERSIZE, IPR_IOADL_FLAGS_READ_LAST);
|
|
|
|
ipr_do_req(ipr_cmd, ipr_erp_done, ipr_timeout,
|
|
IPR_REQUEST_SENSE_TIMEOUT * 2);
|
|
}
|
|
|
|
/**
|
|
* ipr_erp_request_sense - Send request sense to a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a request sense to a device as a result
|
|
* of a check condition.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_erp_request_sense(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_hrr_queue *hrrq = ipr_cmd->hrrq;
|
|
unsigned long hrrq_flags;
|
|
|
|
spin_lock_irqsave(&hrrq->_lock, hrrq_flags);
|
|
__ipr_erp_request_sense(ipr_cmd);
|
|
spin_unlock_irqrestore(&hrrq->_lock, hrrq_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_erp_cancel_all - Send cancel all to a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a cancel all to a device to clear the
|
|
* queue. If we are running TCQ on the device, QERR is set to 1,
|
|
* which means all outstanding ops have been dropped on the floor.
|
|
* Cancel all will return them to us.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_erp_cancel_all(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
|
|
struct ipr_cmd_pkt *cmd_pkt;
|
|
|
|
res->in_erp = 1;
|
|
|
|
ipr_reinit_ipr_cmnd_for_erp(ipr_cmd);
|
|
|
|
if (!scsi_cmd->device->simple_tags) {
|
|
__ipr_erp_request_sense(ipr_cmd);
|
|
return;
|
|
}
|
|
|
|
cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
|
|
cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt->cdb[0] = IPR_CANCEL_ALL_REQUESTS;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_erp_request_sense, ipr_timeout,
|
|
IPR_CANCEL_ALL_TIMEOUT);
|
|
}
|
|
|
|
/**
|
|
* ipr_dump_ioasa - Dump contents of IOASA
|
|
* @ioa_cfg: ioa config struct
|
|
* @ipr_cmd: ipr command struct
|
|
* @res: resource entry struct
|
|
*
|
|
* This function is invoked by the interrupt handler when ops
|
|
* fail. It will log the IOASA if appropriate. Only called
|
|
* for GPDD ops.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_dump_ioasa(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_cmnd *ipr_cmd, struct ipr_resource_entry *res)
|
|
{
|
|
int i;
|
|
u16 data_len;
|
|
u32 ioasc, fd_ioasc;
|
|
struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
|
|
__be32 *ioasa_data = (__be32 *)ioasa;
|
|
int error_index;
|
|
|
|
ioasc = be32_to_cpu(ioasa->hdr.ioasc) & IPR_IOASC_IOASC_MASK;
|
|
fd_ioasc = be32_to_cpu(ioasa->hdr.fd_ioasc) & IPR_IOASC_IOASC_MASK;
|
|
|
|
if (0 == ioasc)
|
|
return;
|
|
|
|
if (ioa_cfg->log_level < IPR_DEFAULT_LOG_LEVEL)
|
|
return;
|
|
|
|
if (ioasc == IPR_IOASC_BUS_WAS_RESET && fd_ioasc)
|
|
error_index = ipr_get_error(fd_ioasc);
|
|
else
|
|
error_index = ipr_get_error(ioasc);
|
|
|
|
if (ioa_cfg->log_level < IPR_MAX_LOG_LEVEL) {
|
|
/* Don't log an error if the IOA already logged one */
|
|
if (ioasa->hdr.ilid != 0)
|
|
return;
|
|
|
|
if (!ipr_is_gscsi(res))
|
|
return;
|
|
|
|
if (ipr_error_table[error_index].log_ioasa == 0)
|
|
return;
|
|
}
|
|
|
|
ipr_res_err(ioa_cfg, res, "%s\n", ipr_error_table[error_index].error);
|
|
|
|
data_len = be16_to_cpu(ioasa->hdr.ret_stat_len);
|
|
if (ioa_cfg->sis64 && sizeof(struct ipr_ioasa64) < data_len)
|
|
data_len = sizeof(struct ipr_ioasa64);
|
|
else if (!ioa_cfg->sis64 && sizeof(struct ipr_ioasa) < data_len)
|
|
data_len = sizeof(struct ipr_ioasa);
|
|
|
|
ipr_err("IOASA Dump:\n");
|
|
|
|
for (i = 0; i < data_len / 4; i += 4) {
|
|
ipr_err("%08X: %08X %08X %08X %08X\n", i*4,
|
|
be32_to_cpu(ioasa_data[i]),
|
|
be32_to_cpu(ioasa_data[i+1]),
|
|
be32_to_cpu(ioasa_data[i+2]),
|
|
be32_to_cpu(ioasa_data[i+3]));
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_gen_sense - Generate SCSI sense data from an IOASA
|
|
* @ioasa: IOASA
|
|
* @sense_buf: sense data buffer
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_gen_sense(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
u32 failing_lba;
|
|
u8 *sense_buf = ipr_cmd->scsi_cmd->sense_buffer;
|
|
struct ipr_resource_entry *res = ipr_cmd->scsi_cmd->device->hostdata;
|
|
struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
|
|
u32 ioasc = be32_to_cpu(ioasa->hdr.ioasc);
|
|
|
|
memset(sense_buf, 0, SCSI_SENSE_BUFFERSIZE);
|
|
|
|
if (ioasc >= IPR_FIRST_DRIVER_IOASC)
|
|
return;
|
|
|
|
ipr_cmd->scsi_cmd->result = SAM_STAT_CHECK_CONDITION;
|
|
|
|
if (ipr_is_vset_device(res) &&
|
|
ioasc == IPR_IOASC_MED_DO_NOT_REALLOC &&
|
|
ioasa->u.vset.failing_lba_hi != 0) {
|
|
sense_buf[0] = 0x72;
|
|
sense_buf[1] = IPR_IOASC_SENSE_KEY(ioasc);
|
|
sense_buf[2] = IPR_IOASC_SENSE_CODE(ioasc);
|
|
sense_buf[3] = IPR_IOASC_SENSE_QUAL(ioasc);
|
|
|
|
sense_buf[7] = 12;
|
|
sense_buf[8] = 0;
|
|
sense_buf[9] = 0x0A;
|
|
sense_buf[10] = 0x80;
|
|
|
|
failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_hi);
|
|
|
|
sense_buf[12] = (failing_lba & 0xff000000) >> 24;
|
|
sense_buf[13] = (failing_lba & 0x00ff0000) >> 16;
|
|
sense_buf[14] = (failing_lba & 0x0000ff00) >> 8;
|
|
sense_buf[15] = failing_lba & 0x000000ff;
|
|
|
|
failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
|
|
|
|
sense_buf[16] = (failing_lba & 0xff000000) >> 24;
|
|
sense_buf[17] = (failing_lba & 0x00ff0000) >> 16;
|
|
sense_buf[18] = (failing_lba & 0x0000ff00) >> 8;
|
|
sense_buf[19] = failing_lba & 0x000000ff;
|
|
} else {
|
|
sense_buf[0] = 0x70;
|
|
sense_buf[2] = IPR_IOASC_SENSE_KEY(ioasc);
|
|
sense_buf[12] = IPR_IOASC_SENSE_CODE(ioasc);
|
|
sense_buf[13] = IPR_IOASC_SENSE_QUAL(ioasc);
|
|
|
|
/* Illegal request */
|
|
if ((IPR_IOASC_SENSE_KEY(ioasc) == 0x05) &&
|
|
(be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_FIELD_POINTER_VALID)) {
|
|
sense_buf[7] = 10; /* additional length */
|
|
|
|
/* IOARCB was in error */
|
|
if (IPR_IOASC_SENSE_CODE(ioasc) == 0x24)
|
|
sense_buf[15] = 0xC0;
|
|
else /* Parameter data was invalid */
|
|
sense_buf[15] = 0x80;
|
|
|
|
sense_buf[16] =
|
|
((IPR_FIELD_POINTER_MASK &
|
|
be32_to_cpu(ioasa->hdr.ioasc_specific)) >> 8) & 0xff;
|
|
sense_buf[17] =
|
|
(IPR_FIELD_POINTER_MASK &
|
|
be32_to_cpu(ioasa->hdr.ioasc_specific)) & 0xff;
|
|
} else {
|
|
if (ioasc == IPR_IOASC_MED_DO_NOT_REALLOC) {
|
|
if (ipr_is_vset_device(res))
|
|
failing_lba = be32_to_cpu(ioasa->u.vset.failing_lba_lo);
|
|
else
|
|
failing_lba = be32_to_cpu(ioasa->u.dasd.failing_lba);
|
|
|
|
sense_buf[0] |= 0x80; /* Or in the Valid bit */
|
|
sense_buf[3] = (failing_lba & 0xff000000) >> 24;
|
|
sense_buf[4] = (failing_lba & 0x00ff0000) >> 16;
|
|
sense_buf[5] = (failing_lba & 0x0000ff00) >> 8;
|
|
sense_buf[6] = failing_lba & 0x000000ff;
|
|
}
|
|
|
|
sense_buf[7] = 6; /* additional length */
|
|
}
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_get_autosense - Copy autosense data to sense buffer
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function copies the autosense buffer to the buffer
|
|
* in the scsi_cmd, if there is autosense available.
|
|
*
|
|
* Return value:
|
|
* 1 if autosense was available / 0 if not
|
|
**/
|
|
static int ipr_get_autosense(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioasa *ioasa = &ipr_cmd->s.ioasa;
|
|
struct ipr_ioasa64 *ioasa64 = &ipr_cmd->s.ioasa64;
|
|
|
|
if ((be32_to_cpu(ioasa->hdr.ioasc_specific) & IPR_AUTOSENSE_VALID) == 0)
|
|
return 0;
|
|
|
|
if (ipr_cmd->ioa_cfg->sis64)
|
|
memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa64->auto_sense.data,
|
|
min_t(u16, be16_to_cpu(ioasa64->auto_sense.auto_sense_len),
|
|
SCSI_SENSE_BUFFERSIZE));
|
|
else
|
|
memcpy(ipr_cmd->scsi_cmd->sense_buffer, ioasa->auto_sense.data,
|
|
min_t(u16, be16_to_cpu(ioasa->auto_sense.auto_sense_len),
|
|
SCSI_SENSE_BUFFERSIZE));
|
|
return 1;
|
|
}
|
|
|
|
/**
|
|
* ipr_erp_start - Process an error response for a SCSI op
|
|
* @ioa_cfg: ioa config struct
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function determines whether or not to initiate ERP
|
|
* on the affected device.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_erp_start(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
struct ipr_resource_entry *res = scsi_cmd->device->hostdata;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
u32 masked_ioasc = ioasc & IPR_IOASC_IOASC_MASK;
|
|
|
|
if (!res) {
|
|
__ipr_scsi_eh_done(ipr_cmd);
|
|
return;
|
|
}
|
|
|
|
if (!ipr_is_gscsi(res) && masked_ioasc != IPR_IOASC_HW_DEV_BUS_STATUS)
|
|
ipr_gen_sense(ipr_cmd);
|
|
|
|
ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
|
|
|
|
switch (masked_ioasc) {
|
|
case IPR_IOASC_ABORTED_CMD_TERM_BY_HOST:
|
|
if (ipr_is_naca_model(res))
|
|
scsi_cmd->result |= (DID_ABORT << 16);
|
|
else
|
|
scsi_cmd->result |= (DID_IMM_RETRY << 16);
|
|
break;
|
|
case IPR_IOASC_IR_RESOURCE_HANDLE:
|
|
case IPR_IOASC_IR_NO_CMDS_TO_2ND_IOA:
|
|
scsi_cmd->result |= (DID_NO_CONNECT << 16);
|
|
break;
|
|
case IPR_IOASC_HW_SEL_TIMEOUT:
|
|
scsi_cmd->result |= (DID_NO_CONNECT << 16);
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
break;
|
|
case IPR_IOASC_SYNC_REQUIRED:
|
|
if (!res->in_erp)
|
|
res->needs_sync_complete = 1;
|
|
scsi_cmd->result |= (DID_IMM_RETRY << 16);
|
|
break;
|
|
case IPR_IOASC_MED_DO_NOT_REALLOC: /* prevent retries */
|
|
case IPR_IOASA_IR_DUAL_IOA_DISABLED:
|
|
/*
|
|
* exception: do not set DID_PASSTHROUGH on CHECK CONDITION
|
|
* so SCSI mid-layer and upper layers handle it accordingly.
|
|
*/
|
|
if (scsi_cmd->result != SAM_STAT_CHECK_CONDITION)
|
|
scsi_cmd->result |= (DID_PASSTHROUGH << 16);
|
|
break;
|
|
case IPR_IOASC_BUS_WAS_RESET:
|
|
case IPR_IOASC_BUS_WAS_RESET_BY_OTHER:
|
|
/*
|
|
* Report the bus reset and ask for a retry. The device
|
|
* will give CC/UA the next command.
|
|
*/
|
|
if (!res->resetting_device)
|
|
scsi_report_bus_reset(ioa_cfg->host, scsi_cmd->device->channel);
|
|
scsi_cmd->result |= (DID_ERROR << 16);
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
break;
|
|
case IPR_IOASC_HW_DEV_BUS_STATUS:
|
|
scsi_cmd->result |= IPR_IOASC_SENSE_STATUS(ioasc);
|
|
if (IPR_IOASC_SENSE_STATUS(ioasc) == SAM_STAT_CHECK_CONDITION) {
|
|
if (!ipr_get_autosense(ipr_cmd)) {
|
|
if (!ipr_is_naca_model(res)) {
|
|
ipr_erp_cancel_all(ipr_cmd);
|
|
return;
|
|
}
|
|
}
|
|
}
|
|
if (!ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
break;
|
|
case IPR_IOASC_NR_INIT_CMD_REQUIRED:
|
|
break;
|
|
case IPR_IOASC_IR_NON_OPTIMIZED:
|
|
if (res->raw_mode) {
|
|
res->raw_mode = 0;
|
|
scsi_cmd->result |= (DID_IMM_RETRY << 16);
|
|
} else
|
|
scsi_cmd->result |= (DID_ERROR << 16);
|
|
break;
|
|
default:
|
|
if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
|
|
scsi_cmd->result |= (DID_ERROR << 16);
|
|
if (!ipr_is_vset_device(res) && !ipr_is_naca_model(res))
|
|
res->needs_sync_complete = 1;
|
|
break;
|
|
}
|
|
|
|
scsi_dma_unmap(ipr_cmd->scsi_cmd);
|
|
scsi_cmd->scsi_done(scsi_cmd);
|
|
if (ipr_cmd->eh_comp)
|
|
complete(ipr_cmd->eh_comp);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_scsi_done - mid-layer done function
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked by the interrupt handler for
|
|
* ops generated by the SCSI mid-layer
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_scsi_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct scsi_cmnd *scsi_cmd = ipr_cmd->scsi_cmd;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
unsigned long lock_flags;
|
|
|
|
scsi_set_resid(scsi_cmd, be32_to_cpu(ipr_cmd->s.ioasa.hdr.residual_data_len));
|
|
|
|
if (likely(IPR_IOASC_SENSE_KEY(ioasc) == 0)) {
|
|
scsi_dma_unmap(scsi_cmd);
|
|
|
|
spin_lock_irqsave(ipr_cmd->hrrq->lock, lock_flags);
|
|
scsi_cmd->scsi_done(scsi_cmd);
|
|
if (ipr_cmd->eh_comp)
|
|
complete(ipr_cmd->eh_comp);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
spin_unlock_irqrestore(ipr_cmd->hrrq->lock, lock_flags);
|
|
} else {
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
spin_lock(&ipr_cmd->hrrq->_lock);
|
|
ipr_erp_start(ioa_cfg, ipr_cmd);
|
|
spin_unlock(&ipr_cmd->hrrq->_lock);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_queuecommand - Queue a mid-layer request
|
|
* @shost: scsi host struct
|
|
* @scsi_cmd: scsi command struct
|
|
*
|
|
* This function queues a request generated by the mid-layer.
|
|
*
|
|
* Return value:
|
|
* 0 on success
|
|
* SCSI_MLQUEUE_DEVICE_BUSY if device is busy
|
|
* SCSI_MLQUEUE_HOST_BUSY if host is busy
|
|
**/
|
|
static int ipr_queuecommand(struct Scsi_Host *shost,
|
|
struct scsi_cmnd *scsi_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
struct ipr_ioarcb *ioarcb;
|
|
struct ipr_cmnd *ipr_cmd;
|
|
unsigned long hrrq_flags, lock_flags;
|
|
int rc;
|
|
struct ipr_hrr_queue *hrrq;
|
|
int hrrq_id;
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *)shost->hostdata;
|
|
|
|
scsi_cmd->result = (DID_OK << 16);
|
|
res = scsi_cmd->device->hostdata;
|
|
|
|
if (ipr_is_gata(res) && res->sata_port) {
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
rc = ata_sas_queuecmd(scsi_cmd, res->sata_port->ap);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return rc;
|
|
}
|
|
|
|
hrrq_id = ipr_get_hrrq_index(ioa_cfg);
|
|
hrrq = &ioa_cfg->hrrq[hrrq_id];
|
|
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
/*
|
|
* We are currently blocking all devices due to a host reset
|
|
* We have told the host to stop giving us new requests, but
|
|
* ERP ops don't count. FIXME
|
|
*/
|
|
if (unlikely(!hrrq->allow_cmds && !hrrq->ioa_is_dead && !hrrq->removing_ioa)) {
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
}
|
|
|
|
/*
|
|
* FIXME - Create scsi_set_host_offline interface
|
|
* and the ioa_is_dead check can be removed
|
|
*/
|
|
if (unlikely(hrrq->ioa_is_dead || hrrq->removing_ioa || !res)) {
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
goto err_nodev;
|
|
}
|
|
|
|
ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
|
|
if (ipr_cmd == NULL) {
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
}
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
|
|
ipr_init_ipr_cmnd(ipr_cmd, ipr_scsi_done);
|
|
ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
memcpy(ioarcb->cmd_pkt.cdb, scsi_cmd->cmnd, scsi_cmd->cmd_len);
|
|
ipr_cmd->scsi_cmd = scsi_cmd;
|
|
ipr_cmd->done = ipr_scsi_eh_done;
|
|
|
|
if (ipr_is_gscsi(res)) {
|
|
if (scsi_cmd->underflow == 0)
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
|
|
|
|
if (res->reset_occurred) {
|
|
res->reset_occurred = 0;
|
|
ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_DELAY_AFTER_RST;
|
|
}
|
|
}
|
|
|
|
if (ipr_is_gscsi(res) || ipr_is_vset_device(res)) {
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
|
|
|
|
ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_ALIGNED_BFR;
|
|
if (scsi_cmd->flags & SCMD_TAGGED)
|
|
ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_SIMPLE_TASK;
|
|
else
|
|
ioarcb->cmd_pkt.flags_lo |= IPR_FLAGS_LO_UNTAGGED_TASK;
|
|
}
|
|
|
|
if (scsi_cmd->cmnd[0] >= 0xC0 &&
|
|
(!ipr_is_gscsi(res) || scsi_cmd->cmnd[0] == IPR_QUERY_RSRC_STATE)) {
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
}
|
|
if (res->raw_mode && ipr_is_af_dasd_device(res)) {
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_PIPE;
|
|
|
|
if (scsi_cmd->underflow == 0)
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
|
|
}
|
|
|
|
if (ioa_cfg->sis64)
|
|
rc = ipr_build_ioadl64(ioa_cfg, ipr_cmd);
|
|
else
|
|
rc = ipr_build_ioadl(ioa_cfg, ipr_cmd);
|
|
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
if (unlikely(rc || (!hrrq->allow_cmds && !hrrq->ioa_is_dead))) {
|
|
list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
if (!rc)
|
|
scsi_dma_unmap(scsi_cmd);
|
|
return SCSI_MLQUEUE_HOST_BUSY;
|
|
}
|
|
|
|
if (unlikely(hrrq->ioa_is_dead)) {
|
|
list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_free_q);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
scsi_dma_unmap(scsi_cmd);
|
|
goto err_nodev;
|
|
}
|
|
|
|
ioarcb->res_handle = res->res_handle;
|
|
if (res->needs_sync_complete) {
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_SYNC_COMPLETE;
|
|
res->needs_sync_complete = 0;
|
|
}
|
|
list_add_tail(&ipr_cmd->queue, &hrrq->hrrq_pending_q);
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
|
|
ipr_send_command(ipr_cmd);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return 0;
|
|
|
|
err_nodev:
|
|
spin_lock_irqsave(hrrq->lock, hrrq_flags);
|
|
memset(scsi_cmd->sense_buffer, 0, SCSI_SENSE_BUFFERSIZE);
|
|
scsi_cmd->result = (DID_NO_CONNECT << 16);
|
|
scsi_cmd->scsi_done(scsi_cmd);
|
|
spin_unlock_irqrestore(hrrq->lock, hrrq_flags);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioctl - IOCTL handler
|
|
* @sdev: scsi device struct
|
|
* @cmd: IOCTL cmd
|
|
* @arg: IOCTL arg
|
|
*
|
|
* Return value:
|
|
* 0 on success / other on failure
|
|
**/
|
|
static int ipr_ioctl(struct scsi_device *sdev, int cmd, void __user *arg)
|
|
{
|
|
struct ipr_resource_entry *res;
|
|
|
|
res = (struct ipr_resource_entry *)sdev->hostdata;
|
|
if (res && ipr_is_gata(res)) {
|
|
if (cmd == HDIO_GET_IDENTITY)
|
|
return -ENOTTY;
|
|
return ata_sas_scsi_ioctl(res->sata_port->ap, sdev, cmd, arg);
|
|
}
|
|
|
|
return -EINVAL;
|
|
}
|
|
|
|
/**
|
|
* ipr_info - Get information about the card/driver
|
|
* @scsi_host: scsi host struct
|
|
*
|
|
* Return value:
|
|
* pointer to buffer with description string
|
|
**/
|
|
static const char *ipr_ioa_info(struct Scsi_Host *host)
|
|
{
|
|
static char buffer[512];
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
unsigned long lock_flags = 0;
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *) host->hostdata;
|
|
|
|
spin_lock_irqsave(host->host_lock, lock_flags);
|
|
sprintf(buffer, "IBM %X Storage Adapter", ioa_cfg->type);
|
|
spin_unlock_irqrestore(host->host_lock, lock_flags);
|
|
|
|
return buffer;
|
|
}
|
|
|
|
static struct scsi_host_template driver_template = {
|
|
.module = THIS_MODULE,
|
|
.name = "IPR",
|
|
.info = ipr_ioa_info,
|
|
.ioctl = ipr_ioctl,
|
|
.queuecommand = ipr_queuecommand,
|
|
.eh_abort_handler = ipr_eh_abort,
|
|
.eh_device_reset_handler = ipr_eh_dev_reset,
|
|
.eh_host_reset_handler = ipr_eh_host_reset,
|
|
.slave_alloc = ipr_slave_alloc,
|
|
.slave_configure = ipr_slave_configure,
|
|
.slave_destroy = ipr_slave_destroy,
|
|
.scan_finished = ipr_scan_finished,
|
|
.target_alloc = ipr_target_alloc,
|
|
.target_destroy = ipr_target_destroy,
|
|
.change_queue_depth = ipr_change_queue_depth,
|
|
.bios_param = ipr_biosparam,
|
|
.can_queue = IPR_MAX_COMMANDS,
|
|
.this_id = -1,
|
|
.sg_tablesize = IPR_MAX_SGLIST,
|
|
.max_sectors = IPR_IOA_MAX_SECTORS,
|
|
.cmd_per_lun = IPR_MAX_CMD_PER_LUN,
|
|
.use_clustering = ENABLE_CLUSTERING,
|
|
.shost_attrs = ipr_ioa_attrs,
|
|
.sdev_attrs = ipr_dev_attrs,
|
|
.proc_name = IPR_NAME,
|
|
};
|
|
|
|
/**
|
|
* ipr_ata_phy_reset - libata phy_reset handler
|
|
* @ap: ata port to reset
|
|
*
|
|
**/
|
|
static void ipr_ata_phy_reset(struct ata_port *ap)
|
|
{
|
|
unsigned long flags;
|
|
struct ipr_sata_port *sata_port = ap->private_data;
|
|
struct ipr_resource_entry *res = sata_port->res;
|
|
struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
|
|
int rc;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds)
|
|
goto out_unlock;
|
|
|
|
rc = ipr_device_reset(ioa_cfg, res);
|
|
|
|
if (rc) {
|
|
ap->link.device[0].class = ATA_DEV_NONE;
|
|
goto out_unlock;
|
|
}
|
|
|
|
ap->link.device[0].class = res->ata_class;
|
|
if (ap->link.device[0].class == ATA_DEV_UNKNOWN)
|
|
ap->link.device[0].class = ATA_DEV_NONE;
|
|
|
|
out_unlock:
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_ata_post_internal - Cleanup after an internal command
|
|
* @qc: ATA queued command
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_ata_post_internal(struct ata_queued_cmd *qc)
|
|
{
|
|
struct ipr_sata_port *sata_port = qc->ap->private_data;
|
|
struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_hrr_queue *hrrq;
|
|
unsigned long flags;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
list_for_each_entry(ipr_cmd, &hrrq->hrrq_pending_q, queue) {
|
|
if (ipr_cmd->qc == qc) {
|
|
ipr_device_reset(ioa_cfg, sata_port->res);
|
|
break;
|
|
}
|
|
}
|
|
spin_unlock(&hrrq->_lock);
|
|
}
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_copy_sata_tf - Copy a SATA taskfile to an IOA data structure
|
|
* @regs: destination
|
|
* @tf: source ATA taskfile
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_copy_sata_tf(struct ipr_ioarcb_ata_regs *regs,
|
|
struct ata_taskfile *tf)
|
|
{
|
|
regs->feature = tf->feature;
|
|
regs->nsect = tf->nsect;
|
|
regs->lbal = tf->lbal;
|
|
regs->lbam = tf->lbam;
|
|
regs->lbah = tf->lbah;
|
|
regs->device = tf->device;
|
|
regs->command = tf->command;
|
|
regs->hob_feature = tf->hob_feature;
|
|
regs->hob_nsect = tf->hob_nsect;
|
|
regs->hob_lbal = tf->hob_lbal;
|
|
regs->hob_lbam = tf->hob_lbam;
|
|
regs->hob_lbah = tf->hob_lbah;
|
|
regs->ctl = tf->ctl;
|
|
}
|
|
|
|
/**
|
|
* ipr_sata_done - done function for SATA commands
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked by the interrupt handler for
|
|
* ops generated by the SCSI mid-layer to SATA devices
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_sata_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ata_queued_cmd *qc = ipr_cmd->qc;
|
|
struct ipr_sata_port *sata_port = qc->ap->private_data;
|
|
struct ipr_resource_entry *res = sata_port->res;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
spin_lock(&ipr_cmd->hrrq->_lock);
|
|
if (ipr_cmd->ioa_cfg->sis64)
|
|
memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa64.u.gata,
|
|
sizeof(struct ipr_ioasa_gata));
|
|
else
|
|
memcpy(&sata_port->ioasa, &ipr_cmd->s.ioasa.u.gata,
|
|
sizeof(struct ipr_ioasa_gata));
|
|
ipr_dump_ioasa(ioa_cfg, ipr_cmd, res);
|
|
|
|
if (be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc_specific) & IPR_ATA_DEVICE_WAS_RESET)
|
|
scsi_report_device_reset(ioa_cfg->host, res->bus, res->target);
|
|
|
|
if (IPR_IOASC_SENSE_KEY(ioasc) > RECOVERED_ERROR)
|
|
qc->err_mask |= __ac_err_mask(sata_port->ioasa.status);
|
|
else
|
|
qc->err_mask |= ac_err_mask(sata_port->ioasa.status);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
spin_unlock(&ipr_cmd->hrrq->_lock);
|
|
ata_qc_complete(qc);
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ata_ioadl64 - Build an ATA scatter/gather list
|
|
* @ipr_cmd: ipr command struct
|
|
* @qc: ATA queued command
|
|
*
|
|
**/
|
|
static void ipr_build_ata_ioadl64(struct ipr_cmnd *ipr_cmd,
|
|
struct ata_queued_cmd *qc)
|
|
{
|
|
u32 ioadl_flags = 0;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl64_desc *ioadl64 = ipr_cmd->i.ata_ioadl.ioadl64;
|
|
struct ipr_ioadl64_desc *last_ioadl64 = NULL;
|
|
int len = qc->nbytes;
|
|
struct scatterlist *sg;
|
|
unsigned int si;
|
|
dma_addr_t dma_addr = ipr_cmd->dma_addr;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
if (qc->dma_dir == DMA_TO_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_WRITE;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
} else if (qc->dma_dir == DMA_FROM_DEVICE)
|
|
ioadl_flags = IPR_IOADL_FLAGS_READ;
|
|
|
|
ioarcb->data_transfer_length = cpu_to_be32(len);
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl64_desc) * ipr_cmd->dma_use_sg);
|
|
ioarcb->u.sis64_addr_data.data_ioadl_addr =
|
|
cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ata_ioadl.ioadl64));
|
|
|
|
for_each_sg(qc->sg, sg, qc->n_elem, si) {
|
|
ioadl64->flags = cpu_to_be32(ioadl_flags);
|
|
ioadl64->data_len = cpu_to_be32(sg_dma_len(sg));
|
|
ioadl64->address = cpu_to_be64(sg_dma_address(sg));
|
|
|
|
last_ioadl64 = ioadl64;
|
|
ioadl64++;
|
|
}
|
|
|
|
if (likely(last_ioadl64))
|
|
last_ioadl64->flags |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_build_ata_ioadl - Build an ATA scatter/gather list
|
|
* @ipr_cmd: ipr command struct
|
|
* @qc: ATA queued command
|
|
*
|
|
**/
|
|
static void ipr_build_ata_ioadl(struct ipr_cmnd *ipr_cmd,
|
|
struct ata_queued_cmd *qc)
|
|
{
|
|
u32 ioadl_flags = 0;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioadl_desc *ioadl = ipr_cmd->i.ioadl;
|
|
struct ipr_ioadl_desc *last_ioadl = NULL;
|
|
int len = qc->nbytes;
|
|
struct scatterlist *sg;
|
|
unsigned int si;
|
|
|
|
if (len == 0)
|
|
return;
|
|
|
|
if (qc->dma_dir == DMA_TO_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_WRITE;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->data_transfer_length = cpu_to_be32(len);
|
|
ioarcb->ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
|
|
} else if (qc->dma_dir == DMA_FROM_DEVICE) {
|
|
ioadl_flags = IPR_IOADL_FLAGS_READ;
|
|
ioarcb->read_data_transfer_length = cpu_to_be32(len);
|
|
ioarcb->read_ioadl_len =
|
|
cpu_to_be32(sizeof(struct ipr_ioadl_desc) * ipr_cmd->dma_use_sg);
|
|
}
|
|
|
|
for_each_sg(qc->sg, sg, qc->n_elem, si) {
|
|
ioadl->flags_and_data_len = cpu_to_be32(ioadl_flags | sg_dma_len(sg));
|
|
ioadl->address = cpu_to_be32(sg_dma_address(sg));
|
|
|
|
last_ioadl = ioadl;
|
|
ioadl++;
|
|
}
|
|
|
|
if (likely(last_ioadl))
|
|
last_ioadl->flags_and_data_len |= cpu_to_be32(IPR_IOADL_FLAGS_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_qc_defer - Get a free ipr_cmd
|
|
* @qc: queued command
|
|
*
|
|
* Return value:
|
|
* 0 if success
|
|
**/
|
|
static int ipr_qc_defer(struct ata_queued_cmd *qc)
|
|
{
|
|
struct ata_port *ap = qc->ap;
|
|
struct ipr_sata_port *sata_port = ap->private_data;
|
|
struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_hrr_queue *hrrq;
|
|
int hrrq_id;
|
|
|
|
hrrq_id = ipr_get_hrrq_index(ioa_cfg);
|
|
hrrq = &ioa_cfg->hrrq[hrrq_id];
|
|
|
|
qc->lldd_task = NULL;
|
|
spin_lock(&hrrq->_lock);
|
|
if (unlikely(hrrq->ioa_is_dead)) {
|
|
spin_unlock(&hrrq->_lock);
|
|
return 0;
|
|
}
|
|
|
|
if (unlikely(!hrrq->allow_cmds)) {
|
|
spin_unlock(&hrrq->_lock);
|
|
return ATA_DEFER_LINK;
|
|
}
|
|
|
|
ipr_cmd = __ipr_get_free_ipr_cmnd(hrrq);
|
|
if (ipr_cmd == NULL) {
|
|
spin_unlock(&hrrq->_lock);
|
|
return ATA_DEFER_LINK;
|
|
}
|
|
|
|
qc->lldd_task = ipr_cmd;
|
|
spin_unlock(&hrrq->_lock);
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_qc_issue - Issue a SATA qc to a device
|
|
* @qc: queued command
|
|
*
|
|
* Return value:
|
|
* 0 if success
|
|
**/
|
|
static unsigned int ipr_qc_issue(struct ata_queued_cmd *qc)
|
|
{
|
|
struct ata_port *ap = qc->ap;
|
|
struct ipr_sata_port *sata_port = ap->private_data;
|
|
struct ipr_resource_entry *res = sata_port->res;
|
|
struct ipr_ioa_cfg *ioa_cfg = sata_port->ioa_cfg;
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioarcb *ioarcb;
|
|
struct ipr_ioarcb_ata_regs *regs;
|
|
|
|
if (qc->lldd_task == NULL)
|
|
ipr_qc_defer(qc);
|
|
|
|
ipr_cmd = qc->lldd_task;
|
|
if (ipr_cmd == NULL)
|
|
return AC_ERR_SYSTEM;
|
|
|
|
qc->lldd_task = NULL;
|
|
spin_lock(&ipr_cmd->hrrq->_lock);
|
|
if (unlikely(!ipr_cmd->hrrq->allow_cmds ||
|
|
ipr_cmd->hrrq->ioa_is_dead)) {
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
spin_unlock(&ipr_cmd->hrrq->_lock);
|
|
return AC_ERR_SYSTEM;
|
|
}
|
|
|
|
ipr_init_ipr_cmnd(ipr_cmd, ipr_lock_and_done);
|
|
ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
regs = &ipr_cmd->i.ata_ioadl.regs;
|
|
ioarcb->add_cmd_parms_offset = cpu_to_be16(sizeof(*ioarcb));
|
|
} else
|
|
regs = &ioarcb->u.add_data.u.regs;
|
|
|
|
memset(regs, 0, sizeof(*regs));
|
|
ioarcb->add_cmd_parms_len = cpu_to_be16(sizeof(*regs));
|
|
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
ipr_cmd->qc = qc;
|
|
ipr_cmd->done = ipr_sata_done;
|
|
ipr_cmd->ioarcb.res_handle = res->res_handle;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_ATA_PASSTHRU;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_LINK_DESC;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_NO_ULEN_CHK;
|
|
ipr_cmd->dma_use_sg = qc->n_elem;
|
|
|
|
if (ioa_cfg->sis64)
|
|
ipr_build_ata_ioadl64(ipr_cmd, qc);
|
|
else
|
|
ipr_build_ata_ioadl(ipr_cmd, qc);
|
|
|
|
regs->flags |= IPR_ATA_FLAG_STATUS_ON_GOOD_COMPLETION;
|
|
ipr_copy_sata_tf(regs, &qc->tf);
|
|
memcpy(ioarcb->cmd_pkt.cdb, qc->cdb, IPR_MAX_CDB_LEN);
|
|
ipr_trc_hook(ipr_cmd, IPR_TRACE_START, IPR_GET_RES_PHYS_LOC(res));
|
|
|
|
switch (qc->tf.protocol) {
|
|
case ATA_PROT_NODATA:
|
|
case ATA_PROT_PIO:
|
|
break;
|
|
|
|
case ATA_PROT_DMA:
|
|
regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
|
|
break;
|
|
|
|
case ATAPI_PROT_PIO:
|
|
case ATAPI_PROT_NODATA:
|
|
regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
|
|
break;
|
|
|
|
case ATAPI_PROT_DMA:
|
|
regs->flags |= IPR_ATA_FLAG_PACKET_CMD;
|
|
regs->flags |= IPR_ATA_FLAG_XFER_TYPE_DMA;
|
|
break;
|
|
|
|
default:
|
|
WARN_ON(1);
|
|
spin_unlock(&ipr_cmd->hrrq->_lock);
|
|
return AC_ERR_INVALID;
|
|
}
|
|
|
|
ipr_send_command(ipr_cmd);
|
|
spin_unlock(&ipr_cmd->hrrq->_lock);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_qc_fill_rtf - Read result TF
|
|
* @qc: ATA queued command
|
|
*
|
|
* Return value:
|
|
* true
|
|
**/
|
|
static bool ipr_qc_fill_rtf(struct ata_queued_cmd *qc)
|
|
{
|
|
struct ipr_sata_port *sata_port = qc->ap->private_data;
|
|
struct ipr_ioasa_gata *g = &sata_port->ioasa;
|
|
struct ata_taskfile *tf = &qc->result_tf;
|
|
|
|
tf->feature = g->error;
|
|
tf->nsect = g->nsect;
|
|
tf->lbal = g->lbal;
|
|
tf->lbam = g->lbam;
|
|
tf->lbah = g->lbah;
|
|
tf->device = g->device;
|
|
tf->command = g->status;
|
|
tf->hob_nsect = g->hob_nsect;
|
|
tf->hob_lbal = g->hob_lbal;
|
|
tf->hob_lbam = g->hob_lbam;
|
|
tf->hob_lbah = g->hob_lbah;
|
|
|
|
return true;
|
|
}
|
|
|
|
static struct ata_port_operations ipr_sata_ops = {
|
|
.phy_reset = ipr_ata_phy_reset,
|
|
.hardreset = ipr_sata_reset,
|
|
.post_internal_cmd = ipr_ata_post_internal,
|
|
.qc_prep = ata_noop_qc_prep,
|
|
.qc_defer = ipr_qc_defer,
|
|
.qc_issue = ipr_qc_issue,
|
|
.qc_fill_rtf = ipr_qc_fill_rtf,
|
|
.port_start = ata_sas_port_start,
|
|
.port_stop = ata_sas_port_stop
|
|
};
|
|
|
|
static struct ata_port_info sata_port_info = {
|
|
.flags = ATA_FLAG_SATA | ATA_FLAG_PIO_DMA |
|
|
ATA_FLAG_SAS_HOST,
|
|
.pio_mask = ATA_PIO4_ONLY,
|
|
.mwdma_mask = ATA_MWDMA2,
|
|
.udma_mask = ATA_UDMA6,
|
|
.port_ops = &ipr_sata_ops
|
|
};
|
|
|
|
#ifdef CONFIG_PPC_PSERIES
|
|
static const u16 ipr_blocked_processors[] = {
|
|
PVR_NORTHSTAR,
|
|
PVR_PULSAR,
|
|
PVR_POWER4,
|
|
PVR_ICESTAR,
|
|
PVR_SSTAR,
|
|
PVR_POWER4p,
|
|
PVR_630,
|
|
PVR_630p
|
|
};
|
|
|
|
/**
|
|
* ipr_invalid_adapter - Determine if this adapter is supported on this hardware
|
|
* @ioa_cfg: ioa cfg struct
|
|
*
|
|
* Adapters that use Gemstone revision < 3.1 do not work reliably on
|
|
* certain pSeries hardware. This function determines if the given
|
|
* adapter is in one of these confgurations or not.
|
|
*
|
|
* Return value:
|
|
* 1 if adapter is not supported / 0 if adapter is supported
|
|
**/
|
|
static int ipr_invalid_adapter(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int i;
|
|
|
|
if ((ioa_cfg->type == 0x5702) && (ioa_cfg->pdev->revision < 4)) {
|
|
for (i = 0; i < ARRAY_SIZE(ipr_blocked_processors); i++) {
|
|
if (pvr_version_is(ipr_blocked_processors[i]))
|
|
return 1;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
#else
|
|
#define ipr_invalid_adapter(ioa_cfg) 0
|
|
#endif
|
|
|
|
/**
|
|
* ipr_ioa_bringdown_done - IOA bring down completion.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function processes the completion of an adapter bring down.
|
|
* It wakes any reset sleepers.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioa_bringdown_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int i;
|
|
|
|
ENTER;
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
|
|
ipr_trace;
|
|
ioa_cfg->scsi_unblock = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
}
|
|
|
|
ioa_cfg->in_reset_reload = 0;
|
|
ioa_cfg->reset_retries = 0;
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].ioa_is_dead = 1;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
wake_up_all(&ioa_cfg->reset_wait_q);
|
|
LEAVE;
|
|
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioa_reset_done - IOA reset completion.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function processes the completion of an adapter reset.
|
|
* It schedules any necessary mid-layer add/removes and
|
|
* wakes any reset sleepers.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioa_reset_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_resource_entry *res;
|
|
int j;
|
|
|
|
ENTER;
|
|
ioa_cfg->in_reset_reload = 0;
|
|
for (j = 0; j < ioa_cfg->hrrq_num; j++) {
|
|
spin_lock(&ioa_cfg->hrrq[j]._lock);
|
|
ioa_cfg->hrrq[j].allow_cmds = 1;
|
|
spin_unlock(&ioa_cfg->hrrq[j]._lock);
|
|
}
|
|
wmb();
|
|
ioa_cfg->reset_cmd = NULL;
|
|
ioa_cfg->doorbell |= IPR_RUNTIME_RESET;
|
|
|
|
list_for_each_entry(res, &ioa_cfg->used_res_q, queue) {
|
|
if (res->add_to_ml || res->del_from_ml) {
|
|
ipr_trace;
|
|
break;
|
|
}
|
|
}
|
|
schedule_work(&ioa_cfg->work_q);
|
|
|
|
for (j = 0; j < IPR_NUM_HCAMS; j++) {
|
|
list_del_init(&ioa_cfg->hostrcb[j]->queue);
|
|
if (j < IPR_NUM_LOG_HCAMS)
|
|
ipr_send_hcam(ioa_cfg,
|
|
IPR_HCAM_CDB_OP_CODE_LOG_DATA,
|
|
ioa_cfg->hostrcb[j]);
|
|
else
|
|
ipr_send_hcam(ioa_cfg,
|
|
IPR_HCAM_CDB_OP_CODE_CONFIG_CHANGE,
|
|
ioa_cfg->hostrcb[j]);
|
|
}
|
|
|
|
scsi_report_bus_reset(ioa_cfg->host, IPR_VSET_BUS);
|
|
dev_info(&ioa_cfg->pdev->dev, "IOA initialized.\n");
|
|
|
|
ioa_cfg->reset_retries = 0;
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
wake_up_all(&ioa_cfg->reset_wait_q);
|
|
|
|
ioa_cfg->scsi_unblock = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_set_sup_dev_dflt - Initialize a Set Supported Device buffer
|
|
* @supported_dev: supported device struct
|
|
* @vpids: vendor product id struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_set_sup_dev_dflt(struct ipr_supported_device *supported_dev,
|
|
struct ipr_std_inq_vpids *vpids)
|
|
{
|
|
memset(supported_dev, 0, sizeof(struct ipr_supported_device));
|
|
memcpy(&supported_dev->vpids, vpids, sizeof(struct ipr_std_inq_vpids));
|
|
supported_dev->num_records = 1;
|
|
supported_dev->data_length =
|
|
cpu_to_be16(sizeof(struct ipr_supported_device));
|
|
supported_dev->reserved = 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_set_supported_devs - Send Set Supported Devices for a device
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Set Supported Devices to the adapter
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_set_supported_devs(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_supported_device *supp_dev = &ioa_cfg->vpd_cbs->supp_dev;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_resource_entry *res = ipr_cmd->u.res;
|
|
|
|
ipr_cmd->job_step = ipr_ioa_reset_done;
|
|
|
|
list_for_each_entry_continue(res, &ioa_cfg->used_res_q, queue) {
|
|
if (!ipr_is_scsi_disk(res))
|
|
continue;
|
|
|
|
ipr_cmd->u.res = res;
|
|
ipr_set_sup_dev_dflt(supp_dev, &res->std_inq_data.vpids);
|
|
|
|
ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
|
|
ioarcb->cmd_pkt.cdb[0] = IPR_SET_SUPPORTED_DEVICES;
|
|
ioarcb->cmd_pkt.cdb[1] = IPR_SET_ALL_SUPPORTED_DEVICES;
|
|
ioarcb->cmd_pkt.cdb[7] = (sizeof(struct ipr_supported_device) >> 8) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[8] = sizeof(struct ipr_supported_device) & 0xff;
|
|
|
|
ipr_init_ioadl(ipr_cmd,
|
|
ioa_cfg->vpd_cbs_dma +
|
|
offsetof(struct ipr_misc_cbs, supp_dev),
|
|
sizeof(struct ipr_supported_device),
|
|
IPR_IOADL_FLAGS_WRITE_LAST);
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
|
|
IPR_SET_SUP_DEVICE_TIMEOUT);
|
|
|
|
if (!ioa_cfg->sis64)
|
|
ipr_cmd->job_step = ipr_set_supported_devs;
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_get_mode_page - Locate specified mode page
|
|
* @mode_pages: mode page buffer
|
|
* @page_code: page code to find
|
|
* @len: minimum required length for mode page
|
|
*
|
|
* Return value:
|
|
* pointer to mode page / NULL on failure
|
|
**/
|
|
static void *ipr_get_mode_page(struct ipr_mode_pages *mode_pages,
|
|
u32 page_code, u32 len)
|
|
{
|
|
struct ipr_mode_page_hdr *mode_hdr;
|
|
u32 page_length;
|
|
u32 length;
|
|
|
|
if (!mode_pages || (mode_pages->hdr.length == 0))
|
|
return NULL;
|
|
|
|
length = (mode_pages->hdr.length + 1) - 4 - mode_pages->hdr.block_desc_len;
|
|
mode_hdr = (struct ipr_mode_page_hdr *)
|
|
(mode_pages->data + mode_pages->hdr.block_desc_len);
|
|
|
|
while (length) {
|
|
if (IPR_GET_MODE_PAGE_CODE(mode_hdr) == page_code) {
|
|
if (mode_hdr->page_length >= (len - sizeof(struct ipr_mode_page_hdr)))
|
|
return mode_hdr;
|
|
break;
|
|
} else {
|
|
page_length = (sizeof(struct ipr_mode_page_hdr) +
|
|
mode_hdr->page_length);
|
|
length -= page_length;
|
|
mode_hdr = (struct ipr_mode_page_hdr *)
|
|
((unsigned long)mode_hdr + page_length);
|
|
}
|
|
}
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ipr_check_term_power - Check for term power errors
|
|
* @ioa_cfg: ioa config struct
|
|
* @mode_pages: IOAFP mode pages buffer
|
|
*
|
|
* Check the IOAFP's mode page 28 for term power errors
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_check_term_power(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_mode_pages *mode_pages)
|
|
{
|
|
int i;
|
|
int entry_length;
|
|
struct ipr_dev_bus_entry *bus;
|
|
struct ipr_mode_page28 *mode_page;
|
|
|
|
mode_page = ipr_get_mode_page(mode_pages, 0x28,
|
|
sizeof(struct ipr_mode_page28));
|
|
|
|
entry_length = mode_page->entry_length;
|
|
|
|
bus = mode_page->bus;
|
|
|
|
for (i = 0; i < mode_page->num_entries; i++) {
|
|
if (bus->flags & IPR_SCSI_ATTR_NO_TERM_PWR) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Term power is absent on scsi bus %d\n",
|
|
bus->res_addr.bus);
|
|
}
|
|
|
|
bus = (struct ipr_dev_bus_entry *)((char *)bus + entry_length);
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_scsi_bus_speed_limit - Limit the SCSI speed based on SES table
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Looks through the config table checking for SES devices. If
|
|
* the SES device is in the SES table indicating a maximum SCSI
|
|
* bus speed, the speed is limited for the bus.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_scsi_bus_speed_limit(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
u32 max_xfer_rate;
|
|
int i;
|
|
|
|
for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
|
|
max_xfer_rate = ipr_get_max_scsi_speed(ioa_cfg, i,
|
|
ioa_cfg->bus_attr[i].bus_width);
|
|
|
|
if (max_xfer_rate < ioa_cfg->bus_attr[i].max_xfer_rate)
|
|
ioa_cfg->bus_attr[i].max_xfer_rate = max_xfer_rate;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_modify_ioafp_mode_page_28 - Modify IOAFP Mode Page 28
|
|
* @ioa_cfg: ioa config struct
|
|
* @mode_pages: mode page 28 buffer
|
|
*
|
|
* Updates mode page 28 based on driver configuration
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_modify_ioafp_mode_page_28(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct ipr_mode_pages *mode_pages)
|
|
{
|
|
int i, entry_length;
|
|
struct ipr_dev_bus_entry *bus;
|
|
struct ipr_bus_attributes *bus_attr;
|
|
struct ipr_mode_page28 *mode_page;
|
|
|
|
mode_page = ipr_get_mode_page(mode_pages, 0x28,
|
|
sizeof(struct ipr_mode_page28));
|
|
|
|
entry_length = mode_page->entry_length;
|
|
|
|
/* Loop for each device bus entry */
|
|
for (i = 0, bus = mode_page->bus;
|
|
i < mode_page->num_entries;
|
|
i++, bus = (struct ipr_dev_bus_entry *)((u8 *)bus + entry_length)) {
|
|
if (bus->res_addr.bus > IPR_MAX_NUM_BUSES) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Invalid resource address reported: 0x%08X\n",
|
|
IPR_GET_PHYS_LOC(bus->res_addr));
|
|
continue;
|
|
}
|
|
|
|
bus_attr = &ioa_cfg->bus_attr[i];
|
|
bus->extended_reset_delay = IPR_EXTENDED_RESET_DELAY;
|
|
bus->bus_width = bus_attr->bus_width;
|
|
bus->max_xfer_rate = cpu_to_be32(bus_attr->max_xfer_rate);
|
|
bus->flags &= ~IPR_SCSI_ATTR_QAS_MASK;
|
|
if (bus_attr->qas_enabled)
|
|
bus->flags |= IPR_SCSI_ATTR_ENABLE_QAS;
|
|
else
|
|
bus->flags |= IPR_SCSI_ATTR_DISABLE_QAS;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_build_mode_select - Build a mode select command
|
|
* @ipr_cmd: ipr command struct
|
|
* @res_handle: resource handle to send command to
|
|
* @parm: Byte 2 of Mode Sense command
|
|
* @dma_addr: DMA buffer address
|
|
* @xfer_len: data transfer length
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_build_mode_select(struct ipr_cmnd *ipr_cmd,
|
|
__be32 res_handle, u8 parm,
|
|
dma_addr_t dma_addr, u8 xfer_len)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
ioarcb->res_handle = res_handle;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
|
|
ioarcb->cmd_pkt.flags_hi |= IPR_FLAGS_HI_WRITE_NOT_READ;
|
|
ioarcb->cmd_pkt.cdb[0] = MODE_SELECT;
|
|
ioarcb->cmd_pkt.cdb[1] = parm;
|
|
ioarcb->cmd_pkt.cdb[4] = xfer_len;
|
|
|
|
ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_WRITE_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_mode_select_page28 - Issue Mode Select Page 28 to IOA
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sets up the SCSI bus attributes and sends
|
|
* a Mode Select for Page 28 to activate them.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_mode_select_page28(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
|
|
int length;
|
|
|
|
ENTER;
|
|
ipr_scsi_bus_speed_limit(ioa_cfg);
|
|
ipr_check_term_power(ioa_cfg, mode_pages);
|
|
ipr_modify_ioafp_mode_page_28(ioa_cfg, mode_pages);
|
|
length = mode_pages->hdr.length + 1;
|
|
mode_pages->hdr.length = 0;
|
|
|
|
ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
|
|
length);
|
|
|
|
ipr_cmd->job_step = ipr_set_supported_devs;
|
|
ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
|
|
struct ipr_resource_entry, queue);
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_build_mode_sense - Builds a mode sense command
|
|
* @ipr_cmd: ipr command struct
|
|
* @res: resource entry struct
|
|
* @parm: Byte 2 of mode sense command
|
|
* @dma_addr: DMA address of mode sense buffer
|
|
* @xfer_len: Size of DMA buffer
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_build_mode_sense(struct ipr_cmnd *ipr_cmd,
|
|
__be32 res_handle,
|
|
u8 parm, dma_addr_t dma_addr, u8 xfer_len)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
ioarcb->res_handle = res_handle;
|
|
ioarcb->cmd_pkt.cdb[0] = MODE_SENSE;
|
|
ioarcb->cmd_pkt.cdb[2] = parm;
|
|
ioarcb->cmd_pkt.cdb[4] = xfer_len;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
|
|
|
|
ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_cmd_failed - Handle failure of IOA reset command
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function handles the failure of an IOA bringup command.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_cmd_failed(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"0x%02X failed with IOASC: 0x%08X\n",
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[0], ioasc);
|
|
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_mode_sense_failed - Handle failure of IOAFP mode sense
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function handles the failure of a Mode Sense to the IOAFP.
|
|
* Some adapters do not handle all mode pages.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_mode_sense_failed(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
|
|
ipr_cmd->job_step = ipr_set_supported_devs;
|
|
ipr_cmd->u.res = list_entry(ioa_cfg->used_res_q.next,
|
|
struct ipr_resource_entry, queue);
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
return ipr_reset_cmd_failed(ipr_cmd);
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_mode_sense_page28 - Issue Mode Sense Page 28 to IOA
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function send a Page 28 mode sense to the IOA to
|
|
* retrieve SCSI bus attributes.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_mode_sense_page28(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
|
|
0x28, ioa_cfg->vpd_cbs_dma +
|
|
offsetof(struct ipr_misc_cbs, mode_pages),
|
|
sizeof(struct ipr_mode_pages));
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_mode_select_page28;
|
|
ipr_cmd->job_step_failed = ipr_reset_mode_sense_failed;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_mode_select_page24 - Issue Mode Select to IOA
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function enables dual IOA RAID support if possible.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_mode_select_page24(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_mode_pages *mode_pages = &ioa_cfg->vpd_cbs->mode_pages;
|
|
struct ipr_mode_page24 *mode_page;
|
|
int length;
|
|
|
|
ENTER;
|
|
mode_page = ipr_get_mode_page(mode_pages, 0x24,
|
|
sizeof(struct ipr_mode_page24));
|
|
|
|
if (mode_page)
|
|
mode_page->flags |= IPR_ENABLE_DUAL_IOA_AF;
|
|
|
|
length = mode_pages->hdr.length + 1;
|
|
mode_pages->hdr.length = 0;
|
|
|
|
ipr_build_mode_select(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE), 0x11,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, mode_pages),
|
|
length);
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_mode_sense_page24_failed - Handle failure of IOAFP mode sense
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function handles the failure of a Mode Sense to the IOAFP.
|
|
* Some adapters do not handle all mode pages.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_mode_sense_page24_failed(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT) {
|
|
ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
return ipr_reset_cmd_failed(ipr_cmd);
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_mode_sense_page24 - Issue Page 24 Mode Sense to IOA
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function send a mode sense to the IOA to retrieve
|
|
* the IOA Advanced Function Control mode page.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_mode_sense_page24(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
ipr_build_mode_sense(ipr_cmd, cpu_to_be32(IPR_IOA_RES_HANDLE),
|
|
0x24, ioa_cfg->vpd_cbs_dma +
|
|
offsetof(struct ipr_misc_cbs, mode_pages),
|
|
sizeof(struct ipr_mode_pages));
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_mode_select_page24;
|
|
ipr_cmd->job_step_failed = ipr_reset_mode_sense_page24_failed;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_init_res_table - Initialize the resource table
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function looks through the existing resource table, comparing
|
|
* it with the config table. This function will take care of old/new
|
|
* devices and schedule adding/removing them from the mid-layer
|
|
* as appropriate.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_init_res_table(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_resource_entry *res, *temp;
|
|
struct ipr_config_table_entry_wrapper cfgtew;
|
|
int entries, found, flag, i;
|
|
LIST_HEAD(old_res);
|
|
|
|
ENTER;
|
|
if (ioa_cfg->sis64)
|
|
flag = ioa_cfg->u.cfg_table64->hdr64.flags;
|
|
else
|
|
flag = ioa_cfg->u.cfg_table->hdr.flags;
|
|
|
|
if (flag & IPR_UCODE_DOWNLOAD_REQ)
|
|
dev_err(&ioa_cfg->pdev->dev, "Microcode download required\n");
|
|
|
|
list_for_each_entry_safe(res, temp, &ioa_cfg->used_res_q, queue)
|
|
list_move_tail(&res->queue, &old_res);
|
|
|
|
if (ioa_cfg->sis64)
|
|
entries = be16_to_cpu(ioa_cfg->u.cfg_table64->hdr64.num_entries);
|
|
else
|
|
entries = ioa_cfg->u.cfg_table->hdr.num_entries;
|
|
|
|
for (i = 0; i < entries; i++) {
|
|
if (ioa_cfg->sis64)
|
|
cfgtew.u.cfgte64 = &ioa_cfg->u.cfg_table64->dev[i];
|
|
else
|
|
cfgtew.u.cfgte = &ioa_cfg->u.cfg_table->dev[i];
|
|
found = 0;
|
|
|
|
list_for_each_entry_safe(res, temp, &old_res, queue) {
|
|
if (ipr_is_same_device(res, &cfgtew)) {
|
|
list_move_tail(&res->queue, &ioa_cfg->used_res_q);
|
|
found = 1;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
if (list_empty(&ioa_cfg->free_res_q)) {
|
|
dev_err(&ioa_cfg->pdev->dev, "Too many devices attached\n");
|
|
break;
|
|
}
|
|
|
|
found = 1;
|
|
res = list_entry(ioa_cfg->free_res_q.next,
|
|
struct ipr_resource_entry, queue);
|
|
list_move_tail(&res->queue, &ioa_cfg->used_res_q);
|
|
ipr_init_res_entry(res, &cfgtew);
|
|
res->add_to_ml = 1;
|
|
} else if (res->sdev && (ipr_is_vset_device(res) || ipr_is_scsi_disk(res)))
|
|
res->sdev->allow_restart = 1;
|
|
|
|
if (found)
|
|
ipr_update_res_entry(res, &cfgtew);
|
|
}
|
|
|
|
list_for_each_entry_safe(res, temp, &old_res, queue) {
|
|
if (res->sdev) {
|
|
res->del_from_ml = 1;
|
|
res->res_handle = IPR_INVALID_RES_HANDLE;
|
|
list_move_tail(&res->queue, &ioa_cfg->used_res_q);
|
|
}
|
|
}
|
|
|
|
list_for_each_entry_safe(res, temp, &old_res, queue) {
|
|
ipr_clear_res_target(res);
|
|
list_move_tail(&res->queue, &ioa_cfg->free_res_q);
|
|
}
|
|
|
|
if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
|
|
ipr_cmd->job_step = ipr_ioafp_mode_sense_page24;
|
|
else
|
|
ipr_cmd->job_step = ipr_ioafp_mode_sense_page28;
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_query_ioa_cfg - Send a Query IOA Config to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Query IOA Configuration command
|
|
* to the adapter to retrieve the IOA configuration table.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_query_ioa_cfg(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_inquiry_page3 *ucode_vpd = &ioa_cfg->vpd_cbs->page3_data;
|
|
struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
|
|
|
|
ENTER;
|
|
if (cap->cap & IPR_CAP_DUAL_IOA_RAID)
|
|
ioa_cfg->dual_raid = 1;
|
|
dev_info(&ioa_cfg->pdev->dev, "Adapter firmware version: %02X%02X%02X%02X\n",
|
|
ucode_vpd->major_release, ucode_vpd->card_type,
|
|
ucode_vpd->minor_release[0], ucode_vpd->minor_release[1]);
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
|
|
ioarcb->cmd_pkt.cdb[0] = IPR_QUERY_IOA_CONFIG;
|
|
ioarcb->cmd_pkt.cdb[6] = (ioa_cfg->cfg_table_size >> 16) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[7] = (ioa_cfg->cfg_table_size >> 8) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[8] = ioa_cfg->cfg_table_size & 0xff;
|
|
|
|
ipr_init_ioadl(ipr_cmd, ioa_cfg->cfg_table_dma, ioa_cfg->cfg_table_size,
|
|
IPR_IOADL_FLAGS_READ_LAST);
|
|
|
|
ipr_cmd->job_step = ipr_init_res_table;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
static int ipr_ioa_service_action_failed(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
u32 ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (ioasc == IPR_IOASC_IR_INVALID_REQ_TYPE_OR_PKT)
|
|
return IPR_RC_JOB_CONTINUE;
|
|
|
|
return ipr_reset_cmd_failed(ipr_cmd);
|
|
}
|
|
|
|
static void ipr_build_ioa_service_action(struct ipr_cmnd *ipr_cmd,
|
|
__be32 res_handle, u8 sa_code)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
ioarcb->res_handle = res_handle;
|
|
ioarcb->cmd_pkt.cdb[0] = IPR_IOA_SERVICE_ACTION;
|
|
ioarcb->cmd_pkt.cdb[1] = sa_code;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_set_caching_parameters - Issue Set Cache parameters service
|
|
* action
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static int ipr_ioafp_set_caching_parameters(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
|
|
|
|
ENTER;
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_query_ioa_cfg;
|
|
|
|
if (pageC4->cache_cap[0] & IPR_CAP_SYNC_CACHE) {
|
|
ipr_build_ioa_service_action(ipr_cmd,
|
|
cpu_to_be32(IPR_IOA_RES_HANDLE),
|
|
IPR_IOA_SA_CHANGE_CACHE_PARAMS);
|
|
|
|
ioarcb->cmd_pkt.cdb[2] = 0x40;
|
|
|
|
ipr_cmd->job_step_failed = ipr_ioa_service_action_failed;
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
|
|
IPR_SET_SUP_DEVICE_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_inquiry - Send an Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This utility function sends an inquiry to the adapter.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_ioafp_inquiry(struct ipr_cmnd *ipr_cmd, u8 flags, u8 page,
|
|
dma_addr_t dma_addr, u8 xfer_len)
|
|
{
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
|
|
ENTER;
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
|
|
ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
|
|
ioarcb->cmd_pkt.cdb[0] = INQUIRY;
|
|
ioarcb->cmd_pkt.cdb[1] = flags;
|
|
ioarcb->cmd_pkt.cdb[2] = page;
|
|
ioarcb->cmd_pkt.cdb[4] = xfer_len;
|
|
|
|
ipr_init_ioadl(ipr_cmd, dma_addr, xfer_len, IPR_IOADL_FLAGS_READ_LAST);
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, IPR_INTERNAL_TIMEOUT);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_inquiry_page_supported - Is the given inquiry page supported
|
|
* @page0: inquiry page 0 buffer
|
|
* @page: page code.
|
|
*
|
|
* This function determines if the specified inquiry page is supported.
|
|
*
|
|
* Return value:
|
|
* 1 if page is supported / 0 if not
|
|
**/
|
|
static int ipr_inquiry_page_supported(struct ipr_inquiry_page0 *page0, u8 page)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < min_t(u8, page0->len, IPR_INQUIRY_PAGE0_ENTRIES); i++)
|
|
if (page0->page[i] == page)
|
|
return 1;
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_pageC4_inquiry - Send a Page 0xC4 Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Page 0xC4 inquiry to the adapter
|
|
* to retrieve software VPD information.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_pageC4_inquiry(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
|
|
struct ipr_inquiry_pageC4 *pageC4 = &ioa_cfg->vpd_cbs->pageC4_data;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioafp_set_caching_parameters;
|
|
memset(pageC4, 0, sizeof(*pageC4));
|
|
|
|
if (ipr_inquiry_page_supported(page0, 0xC4)) {
|
|
ipr_ioafp_inquiry(ipr_cmd, 1, 0xC4,
|
|
(ioa_cfg->vpd_cbs_dma
|
|
+ offsetof(struct ipr_misc_cbs,
|
|
pageC4_data)),
|
|
sizeof(struct ipr_inquiry_pageC4));
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_cap_inquiry - Send a Page 0xD0 Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Page 0xD0 inquiry to the adapter
|
|
* to retrieve adapter capabilities.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_cap_inquiry(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_inquiry_page0 *page0 = &ioa_cfg->vpd_cbs->page0_data;
|
|
struct ipr_inquiry_cap *cap = &ioa_cfg->vpd_cbs->cap;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioafp_pageC4_inquiry;
|
|
memset(cap, 0, sizeof(*cap));
|
|
|
|
if (ipr_inquiry_page_supported(page0, 0xD0)) {
|
|
ipr_ioafp_inquiry(ipr_cmd, 1, 0xD0,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, cap),
|
|
sizeof(struct ipr_inquiry_cap));
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_page3_inquiry - Send a Page 3 Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Page 3 inquiry to the adapter
|
|
* to retrieve software VPD information.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_page3_inquiry(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_cap_inquiry;
|
|
|
|
ipr_ioafp_inquiry(ipr_cmd, 1, 3,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page3_data),
|
|
sizeof(struct ipr_inquiry_page3));
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_page0_inquiry - Send a Page 0 Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a Page 0 inquiry to the adapter
|
|
* to retrieve supported inquiry pages.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_page0_inquiry(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
char type[5];
|
|
|
|
ENTER;
|
|
|
|
/* Grab the type out of the VPD and store it away */
|
|
memcpy(type, ioa_cfg->vpd_cbs->ioa_vpd.std_inq_data.vpids.product_id, 4);
|
|
type[4] = '\0';
|
|
ioa_cfg->type = simple_strtoul((char *)type, NULL, 16);
|
|
|
|
if (ipr_invalid_adapter(ioa_cfg)) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Adapter not supported in this hardware configuration.\n");
|
|
|
|
if (!ipr_testmode) {
|
|
ioa_cfg->reset_retries += IPR_NUM_RESET_RELOAD_RETRIES;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
list_add_tail(&ipr_cmd->queue,
|
|
&ioa_cfg->hrrq->hrrq_free_q);
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
}
|
|
|
|
ipr_cmd->job_step = ipr_ioafp_page3_inquiry;
|
|
|
|
ipr_ioafp_inquiry(ipr_cmd, 1, 0,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, page0_data),
|
|
sizeof(struct ipr_inquiry_page0));
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_std_inquiry - Send a Standard Inquiry to the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function sends a standard inquiry to the adapter.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_std_inquiry(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioafp_page0_inquiry;
|
|
|
|
ipr_ioafp_inquiry(ipr_cmd, 0, 0,
|
|
ioa_cfg->vpd_cbs_dma + offsetof(struct ipr_misc_cbs, ioa_vpd),
|
|
sizeof(struct ipr_ioa_vpd));
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_ioafp_identify_hrrq - Send Identify Host RRQ.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function send an Identify Host Request Response Queue
|
|
* command to establish the HRRQ with the adapter.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_ioafp_identify_hrrq(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_ioarcb *ioarcb = &ipr_cmd->ioarcb;
|
|
struct ipr_hrr_queue *hrrq;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioafp_std_inquiry;
|
|
if (ioa_cfg->identify_hrrq_index == 0)
|
|
dev_info(&ioa_cfg->pdev->dev, "Starting IOA initialization sequence.\n");
|
|
|
|
if (ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num) {
|
|
hrrq = &ioa_cfg->hrrq[ioa_cfg->identify_hrrq_index];
|
|
|
|
ioarcb->cmd_pkt.cdb[0] = IPR_ID_HOST_RR_Q;
|
|
ioarcb->res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
|
|
ioarcb->cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
if (ioa_cfg->sis64)
|
|
ioarcb->cmd_pkt.cdb[1] = 0x1;
|
|
|
|
if (ioa_cfg->nvectors == 1)
|
|
ioarcb->cmd_pkt.cdb[1] &= ~IPR_ID_HRRQ_SELE_ENABLE;
|
|
else
|
|
ioarcb->cmd_pkt.cdb[1] |= IPR_ID_HRRQ_SELE_ENABLE;
|
|
|
|
ioarcb->cmd_pkt.cdb[2] =
|
|
((u64) hrrq->host_rrq_dma >> 24) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[3] =
|
|
((u64) hrrq->host_rrq_dma >> 16) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[4] =
|
|
((u64) hrrq->host_rrq_dma >> 8) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[5] =
|
|
((u64) hrrq->host_rrq_dma) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[7] =
|
|
((sizeof(u32) * hrrq->size) >> 8) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[8] =
|
|
(sizeof(u32) * hrrq->size) & 0xff;
|
|
|
|
if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
|
|
ioarcb->cmd_pkt.cdb[9] =
|
|
ioa_cfg->identify_hrrq_index;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
ioarcb->cmd_pkt.cdb[10] =
|
|
((u64) hrrq->host_rrq_dma >> 56) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[11] =
|
|
((u64) hrrq->host_rrq_dma >> 48) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[12] =
|
|
((u64) hrrq->host_rrq_dma >> 40) & 0xff;
|
|
ioarcb->cmd_pkt.cdb[13] =
|
|
((u64) hrrq->host_rrq_dma >> 32) & 0xff;
|
|
}
|
|
|
|
if (ioarcb->cmd_pkt.cdb[1] & IPR_ID_HRRQ_SELE_ENABLE)
|
|
ioarcb->cmd_pkt.cdb[14] =
|
|
ioa_cfg->identify_hrrq_index;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
|
|
IPR_INTERNAL_TIMEOUT);
|
|
|
|
if (++ioa_cfg->identify_hrrq_index < ioa_cfg->hrrq_num)
|
|
ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_timer_done - Adapter reset timer function
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function is used in adapter reset processing
|
|
* for timing events. If the reset_cmd pointer in the IOA
|
|
* config struct is not this adapter's we are doing nested
|
|
* resets and fail_all_ops will take care of freeing the
|
|
* command block.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_reset_timer_done(struct timer_list *t)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = from_timer(ipr_cmd, t, timer);
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
unsigned long lock_flags = 0;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (ioa_cfg->reset_cmd == ipr_cmd) {
|
|
list_del(&ipr_cmd->queue);
|
|
ipr_cmd->done(ipr_cmd);
|
|
}
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_start_timer - Start a timer for adapter reset job
|
|
* @ipr_cmd: ipr command struct
|
|
* @timeout: timeout value
|
|
*
|
|
* Description: This function is used in adapter reset processing
|
|
* for timing events. If the reset_cmd pointer in the IOA
|
|
* config struct is not this adapter's we are doing nested
|
|
* resets and fail_all_ops will take care of freeing the
|
|
* command block.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_reset_start_timer(struct ipr_cmnd *ipr_cmd,
|
|
unsigned long timeout)
|
|
{
|
|
|
|
ENTER;
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
ipr_cmd->done = ipr_reset_ioa_job;
|
|
|
|
ipr_cmd->timer.expires = jiffies + timeout;
|
|
ipr_cmd->timer.function = ipr_reset_timer_done;
|
|
add_timer(&ipr_cmd->timer);
|
|
}
|
|
|
|
/**
|
|
* ipr_init_ioa_mem - Initialize ioa_cfg control block
|
|
* @ioa_cfg: ioa cfg struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_init_ioa_mem(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_hrr_queue *hrrq;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
memset(hrrq->host_rrq, 0, sizeof(u32) * hrrq->size);
|
|
|
|
/* Initialize Host RRQ pointers */
|
|
hrrq->hrrq_start = hrrq->host_rrq;
|
|
hrrq->hrrq_end = &hrrq->host_rrq[hrrq->size - 1];
|
|
hrrq->hrrq_curr = hrrq->hrrq_start;
|
|
hrrq->toggle_bit = 1;
|
|
spin_unlock(&hrrq->_lock);
|
|
}
|
|
wmb();
|
|
|
|
ioa_cfg->identify_hrrq_index = 0;
|
|
if (ioa_cfg->hrrq_num == 1)
|
|
atomic_set(&ioa_cfg->hrrq_index, 0);
|
|
else
|
|
atomic_set(&ioa_cfg->hrrq_index, 1);
|
|
|
|
/* Zero out config table */
|
|
memset(ioa_cfg->u.cfg_table, 0, ioa_cfg->cfg_table_size);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_next_stage - Process IPL stage change based on feedback register.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_next_stage(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
unsigned long stage, stage_time;
|
|
u32 feedback;
|
|
volatile u32 int_reg;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
u64 maskval = 0;
|
|
|
|
feedback = readl(ioa_cfg->regs.init_feedback_reg);
|
|
stage = feedback & IPR_IPL_INIT_STAGE_MASK;
|
|
stage_time = feedback & IPR_IPL_INIT_STAGE_TIME_MASK;
|
|
|
|
ipr_dbg("IPL stage = 0x%lx, IPL stage time = %ld\n", stage, stage_time);
|
|
|
|
/* sanity check the stage_time value */
|
|
if (stage_time == 0)
|
|
stage_time = IPR_IPL_INIT_DEFAULT_STAGE_TIME;
|
|
else if (stage_time < IPR_IPL_INIT_MIN_STAGE_TIME)
|
|
stage_time = IPR_IPL_INIT_MIN_STAGE_TIME;
|
|
else if (stage_time > IPR_LONG_OPERATIONAL_TIMEOUT)
|
|
stage_time = IPR_LONG_OPERATIONAL_TIMEOUT;
|
|
|
|
if (stage == IPR_IPL_INIT_STAGE_UNKNOWN) {
|
|
writel(IPR_PCII_IPL_STAGE_CHANGE, ioa_cfg->regs.set_interrupt_mask_reg);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
stage_time = ioa_cfg->transop_timeout;
|
|
ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
|
|
} else if (stage == IPR_IPL_INIT_STAGE_TRANSOP) {
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
|
|
ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
|
|
maskval = IPR_PCII_IPL_STAGE_CHANGE;
|
|
maskval = (maskval << 32) | IPR_PCII_IOA_TRANS_TO_OPER;
|
|
writeq(maskval, ioa_cfg->regs.set_interrupt_mask_reg);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
}
|
|
|
|
ipr_cmd->timer.expires = jiffies + stage_time * HZ;
|
|
ipr_cmd->timer.function = ipr_oper_timeout;
|
|
ipr_cmd->done = ipr_reset_ioa_job;
|
|
add_timer(&ipr_cmd->timer);
|
|
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_enable_ioa - Enable the IOA following a reset.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function reinitializes some control blocks and
|
|
* enables destructive diagnostics on the adapter.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_enable_ioa(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
volatile u32 int_reg;
|
|
volatile u64 maskval;
|
|
int i;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioafp_identify_hrrq;
|
|
ipr_init_ioa_mem(ioa_cfg);
|
|
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].allow_interrupts = 1;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
if (ioa_cfg->sis64) {
|
|
/* Set the adapter to the correct endian mode. */
|
|
writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
|
|
int_reg = readl(ioa_cfg->regs.endian_swap_reg);
|
|
}
|
|
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
|
|
if (int_reg & IPR_PCII_IOA_TRANS_TO_OPER) {
|
|
writel((IPR_PCII_ERROR_INTERRUPTS | IPR_PCII_HRRQ_UPDATED),
|
|
ioa_cfg->regs.clr_interrupt_mask_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/* Enable destructive diagnostics on IOA */
|
|
writel(ioa_cfg->doorbell, ioa_cfg->regs.set_uproc_interrupt_reg32);
|
|
|
|
if (ioa_cfg->sis64) {
|
|
maskval = IPR_PCII_IPL_STAGE_CHANGE;
|
|
maskval = (maskval << 32) | IPR_PCII_OPER_INTERRUPTS;
|
|
writeq(maskval, ioa_cfg->regs.clr_interrupt_mask_reg);
|
|
} else
|
|
writel(IPR_PCII_OPER_INTERRUPTS, ioa_cfg->regs.clr_interrupt_mask_reg32);
|
|
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
|
|
dev_info(&ioa_cfg->pdev->dev, "Initializing IOA.\n");
|
|
|
|
if (ioa_cfg->sis64) {
|
|
ipr_cmd->job_step = ipr_reset_next_stage;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
ipr_cmd->timer.expires = jiffies + (ioa_cfg->transop_timeout * HZ);
|
|
ipr_cmd->timer.function = ipr_oper_timeout;
|
|
ipr_cmd->done = ipr_reset_ioa_job;
|
|
add_timer(&ipr_cmd->timer);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_wait_for_dump - Wait for a dump to timeout.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function is invoked when an adapter dump has run out
|
|
* of processing time.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_wait_for_dump(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
if (ioa_cfg->sdt_state == GET_DUMP)
|
|
ioa_cfg->sdt_state = WAIT_FOR_DUMP;
|
|
else if (ioa_cfg->sdt_state == READ_DUMP)
|
|
ioa_cfg->sdt_state = ABORT_DUMP;
|
|
|
|
ioa_cfg->dump_timeout = 1;
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_unit_check_no_data - Log a unit check/no data error log
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Logs an error indicating the adapter unit checked, but for some
|
|
* reason, we were unable to fetch the unit check buffer.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_unit_check_no_data(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
ioa_cfg->errors_logged++;
|
|
dev_err(&ioa_cfg->pdev->dev, "IOA unit check with no data\n");
|
|
}
|
|
|
|
/**
|
|
* ipr_get_unit_check_buffer - Get the unit check buffer from the IOA
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Fetches the unit check buffer from the adapter by clocking the data
|
|
* through the mailbox register.
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_get_unit_check_buffer(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
unsigned long mailbox;
|
|
struct ipr_hostrcb *hostrcb;
|
|
struct ipr_uc_sdt sdt;
|
|
int rc, length;
|
|
u32 ioasc;
|
|
|
|
mailbox = readl(ioa_cfg->ioa_mailbox);
|
|
|
|
if (!ioa_cfg->sis64 && !ipr_sdt_is_fmt2(mailbox)) {
|
|
ipr_unit_check_no_data(ioa_cfg);
|
|
return;
|
|
}
|
|
|
|
memset(&sdt, 0, sizeof(struct ipr_uc_sdt));
|
|
rc = ipr_get_ldump_data_section(ioa_cfg, mailbox, (__be32 *) &sdt,
|
|
(sizeof(struct ipr_uc_sdt)) / sizeof(__be32));
|
|
|
|
if (rc || !(sdt.entry[0].flags & IPR_SDT_VALID_ENTRY) ||
|
|
((be32_to_cpu(sdt.hdr.state) != IPR_FMT3_SDT_READY_TO_USE) &&
|
|
(be32_to_cpu(sdt.hdr.state) != IPR_FMT2_SDT_READY_TO_USE))) {
|
|
ipr_unit_check_no_data(ioa_cfg);
|
|
return;
|
|
}
|
|
|
|
/* Find length of the first sdt entry (UC buffer) */
|
|
if (be32_to_cpu(sdt.hdr.state) == IPR_FMT3_SDT_READY_TO_USE)
|
|
length = be32_to_cpu(sdt.entry[0].end_token);
|
|
else
|
|
length = (be32_to_cpu(sdt.entry[0].end_token) -
|
|
be32_to_cpu(sdt.entry[0].start_token)) &
|
|
IPR_FMT2_MBX_ADDR_MASK;
|
|
|
|
hostrcb = list_entry(ioa_cfg->hostrcb_free_q.next,
|
|
struct ipr_hostrcb, queue);
|
|
list_del_init(&hostrcb->queue);
|
|
memset(&hostrcb->hcam, 0, sizeof(hostrcb->hcam));
|
|
|
|
rc = ipr_get_ldump_data_section(ioa_cfg,
|
|
be32_to_cpu(sdt.entry[0].start_token),
|
|
(__be32 *)&hostrcb->hcam,
|
|
min(length, (int)sizeof(hostrcb->hcam)) / sizeof(__be32));
|
|
|
|
if (!rc) {
|
|
ipr_handle_log_data(ioa_cfg, hostrcb);
|
|
ioasc = be32_to_cpu(hostrcb->hcam.u.error.fd_ioasc);
|
|
if (ioasc == IPR_IOASC_NR_IOA_RESET_REQUIRED &&
|
|
ioa_cfg->sdt_state == GET_DUMP)
|
|
ioa_cfg->sdt_state = WAIT_FOR_DUMP;
|
|
} else
|
|
ipr_unit_check_no_data(ioa_cfg);
|
|
|
|
list_add_tail(&hostrcb->queue, &ioa_cfg->hostrcb_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_get_unit_check_job - Call to get the unit check buffer.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function will call to get the unit check buffer.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_get_unit_check_job(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
ioa_cfg->ioa_unit_checked = 0;
|
|
ipr_get_unit_check_buffer(ioa_cfg);
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
ipr_reset_start_timer(ipr_cmd, 0);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
static int ipr_dump_mailbox_wait(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
|
|
if (ioa_cfg->sdt_state != GET_DUMP)
|
|
return IPR_RC_JOB_RETURN;
|
|
|
|
if (!ioa_cfg->sis64 || !ipr_cmd->u.time_left ||
|
|
(readl(ioa_cfg->regs.sense_interrupt_reg) &
|
|
IPR_PCII_MAILBOX_STABLE)) {
|
|
|
|
if (!ipr_cmd->u.time_left)
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Timed out waiting for Mailbox register.\n");
|
|
|
|
ioa_cfg->sdt_state = READ_DUMP;
|
|
ioa_cfg->dump_timeout = 0;
|
|
if (ioa_cfg->sis64)
|
|
ipr_reset_start_timer(ipr_cmd, IPR_SIS64_DUMP_TIMEOUT);
|
|
else
|
|
ipr_reset_start_timer(ipr_cmd, IPR_SIS32_DUMP_TIMEOUT);
|
|
ipr_cmd->job_step = ipr_reset_wait_for_dump;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
|
|
} else {
|
|
ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
|
|
ipr_reset_start_timer(ipr_cmd,
|
|
IPR_CHECK_FOR_RESET_TIMEOUT);
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_restore_cfg_space - Restore PCI config space.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function restores the saved PCI config space of
|
|
* the adapter, fails all outstanding ops back to the callers, and
|
|
* fetches the dump/unit check if applicable to this reset.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_restore_cfg_space(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
u32 int_reg;
|
|
|
|
ENTER;
|
|
ioa_cfg->pdev->state_saved = true;
|
|
pci_restore_state(ioa_cfg->pdev);
|
|
|
|
if (ipr_set_pcix_cmd_reg(ioa_cfg)) {
|
|
ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
ipr_fail_all_ops(ioa_cfg);
|
|
|
|
if (ioa_cfg->sis64) {
|
|
/* Set the adapter to the correct endian mode. */
|
|
writel(IPR_ENDIAN_SWAP_KEY, ioa_cfg->regs.endian_swap_reg);
|
|
int_reg = readl(ioa_cfg->regs.endian_swap_reg);
|
|
}
|
|
|
|
if (ioa_cfg->ioa_unit_checked) {
|
|
if (ioa_cfg->sis64) {
|
|
ipr_cmd->job_step = ipr_reset_get_unit_check_job;
|
|
ipr_reset_start_timer(ipr_cmd, IPR_DUMP_DELAY_TIMEOUT);
|
|
return IPR_RC_JOB_RETURN;
|
|
} else {
|
|
ioa_cfg->ioa_unit_checked = 0;
|
|
ipr_get_unit_check_buffer(ioa_cfg);
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
ipr_reset_start_timer(ipr_cmd, 0);
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
}
|
|
|
|
if (ioa_cfg->in_ioa_bringdown) {
|
|
ipr_cmd->job_step = ipr_ioa_bringdown_done;
|
|
} else if (ioa_cfg->sdt_state == GET_DUMP) {
|
|
ipr_cmd->job_step = ipr_dump_mailbox_wait;
|
|
ipr_cmd->u.time_left = IPR_WAIT_FOR_MAILBOX;
|
|
} else {
|
|
ipr_cmd->job_step = ipr_reset_enable_ioa;
|
|
}
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_bist_done - BIST has completed on the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: Unblock config space and resume the reset process.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_bist_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
if (ioa_cfg->cfg_locked)
|
|
pci_cfg_access_unlock(ioa_cfg->pdev);
|
|
ioa_cfg->cfg_locked = 0;
|
|
ipr_cmd->job_step = ipr_reset_restore_cfg_space;
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_start_bist - Run BIST on the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function runs BIST on the adapter, then delays 2 seconds.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_start_bist(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int rc = PCIBIOS_SUCCESSFUL;
|
|
|
|
ENTER;
|
|
if (ioa_cfg->ipr_chip->bist_method == IPR_MMIO)
|
|
writel(IPR_UPROCI_SIS64_START_BIST,
|
|
ioa_cfg->regs.set_uproc_interrupt_reg32);
|
|
else
|
|
rc = pci_write_config_byte(ioa_cfg->pdev, PCI_BIST, PCI_BIST_START);
|
|
|
|
if (rc == PCIBIOS_SUCCESSFUL) {
|
|
ipr_cmd->job_step = ipr_reset_bist_done;
|
|
ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
|
|
rc = IPR_RC_JOB_RETURN;
|
|
} else {
|
|
if (ioa_cfg->cfg_locked)
|
|
pci_cfg_access_unlock(ipr_cmd->ioa_cfg->pdev);
|
|
ioa_cfg->cfg_locked = 0;
|
|
ipr_cmd->s.ioasa.hdr.ioasc = cpu_to_be32(IPR_IOASC_PCI_ACCESS_ERROR);
|
|
rc = IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_slot_reset_done - Clear PCI reset to the adapter
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This clears PCI reset to the adapter and delays two seconds.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_slot_reset_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_reset_bist_done;
|
|
ipr_reset_start_timer(ipr_cmd, IPR_WAIT_FOR_BIST_TIMEOUT);
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_reset_work - Pulse a PCIe fundamental reset
|
|
* @work: work struct
|
|
*
|
|
* Description: This pulses warm reset to a slot.
|
|
*
|
|
**/
|
|
static void ipr_reset_reset_work(struct work_struct *work)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd = container_of(work, struct ipr_cmnd, work);
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct pci_dev *pdev = ioa_cfg->pdev;
|
|
unsigned long lock_flags = 0;
|
|
|
|
ENTER;
|
|
pci_set_pcie_reset_state(pdev, pcie_warm_reset);
|
|
msleep(jiffies_to_msecs(IPR_PCI_RESET_TIMEOUT));
|
|
pci_set_pcie_reset_state(pdev, pcie_deassert_reset);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->reset_cmd == ipr_cmd)
|
|
ipr_reset_ioa_job(ipr_cmd);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_slot_reset - Reset the PCI slot of the adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This asserts PCI reset to the adapter.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_slot_reset(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
INIT_WORK(&ipr_cmd->work, ipr_reset_reset_work);
|
|
queue_work(ioa_cfg->reset_work_q, &ipr_cmd->work);
|
|
ipr_cmd->job_step = ipr_reset_slot_reset_done;
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_block_config_access_wait - Wait for permission to block config access
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This attempts to block config access to the IOA.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_block_config_access_wait(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int rc = IPR_RC_JOB_CONTINUE;
|
|
|
|
if (pci_cfg_access_trylock(ioa_cfg->pdev)) {
|
|
ioa_cfg->cfg_locked = 1;
|
|
ipr_cmd->job_step = ioa_cfg->reset;
|
|
} else {
|
|
if (ipr_cmd->u.time_left) {
|
|
rc = IPR_RC_JOB_RETURN;
|
|
ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
|
|
ipr_reset_start_timer(ipr_cmd,
|
|
IPR_CHECK_FOR_RESET_TIMEOUT);
|
|
} else {
|
|
ipr_cmd->job_step = ioa_cfg->reset;
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"Timed out waiting to lock config access. Resetting anyway.\n");
|
|
}
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_block_config_access - Block config access to the IOA
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This attempts to block config access to the IOA
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_block_config_access(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
ipr_cmd->ioa_cfg->cfg_locked = 0;
|
|
ipr_cmd->job_step = ipr_reset_block_config_access_wait;
|
|
ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_allowed - Query whether or not IOA can be reset
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 if reset not allowed / non-zero if reset is allowed
|
|
**/
|
|
static int ipr_reset_allowed(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
volatile u32 temp_reg;
|
|
|
|
temp_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
return ((temp_reg & IPR_PCII_CRITICAL_OPERATION) == 0);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_wait_to_start_bist - Wait for permission to reset IOA.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function waits for adapter permission to run BIST,
|
|
* then runs BIST. If the adapter does not give permission after a
|
|
* reasonable time, we will reset the adapter anyway. The impact of
|
|
* resetting the adapter without warning the adapter is the risk of
|
|
* losing the persistent error log on the adapter. If the adapter is
|
|
* reset while it is writing to the flash on the adapter, the flash
|
|
* segment will have bad ECC and be zeroed.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_wait_to_start_bist(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int rc = IPR_RC_JOB_RETURN;
|
|
|
|
if (!ipr_reset_allowed(ioa_cfg) && ipr_cmd->u.time_left) {
|
|
ipr_cmd->u.time_left -= IPR_CHECK_FOR_RESET_TIMEOUT;
|
|
ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
|
|
} else {
|
|
ipr_cmd->job_step = ipr_reset_block_config_access;
|
|
rc = IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_alert - Alert the adapter of a pending reset
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function alerts the adapter that it will be reset.
|
|
* If memory space is not currently enabled, proceed directly
|
|
* to running BIST on the adapter. The timer must always be started
|
|
* so we guarantee we do not run BIST from ipr_isr.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_alert(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
u16 cmd_reg;
|
|
int rc;
|
|
|
|
ENTER;
|
|
rc = pci_read_config_word(ioa_cfg->pdev, PCI_COMMAND, &cmd_reg);
|
|
|
|
if ((rc == PCIBIOS_SUCCESSFUL) && (cmd_reg & PCI_COMMAND_MEMORY)) {
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~0);
|
|
writel(IPR_UPROCI_RESET_ALERT, ioa_cfg->regs.set_uproc_interrupt_reg32);
|
|
ipr_cmd->job_step = ipr_reset_wait_to_start_bist;
|
|
} else {
|
|
ipr_cmd->job_step = ipr_reset_block_config_access;
|
|
}
|
|
|
|
ipr_cmd->u.time_left = IPR_WAIT_FOR_RESET_TIMEOUT;
|
|
ipr_reset_start_timer(ipr_cmd, IPR_CHECK_FOR_RESET_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_quiesce_done - Complete IOA disconnect
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: Freeze the adapter to complete quiesce processing
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_quiesce_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_ioa_bringdown_done;
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
|
|
LEAVE;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_cancel_hcam_done - Check for outstanding commands
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: Ensure nothing is outstanding to the IOA and
|
|
* proceed with IOA disconnect. Otherwise reset the IOA.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_RETURN / IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_cancel_hcam_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_cmnd *loop_cmd;
|
|
struct ipr_hrr_queue *hrrq;
|
|
int rc = IPR_RC_JOB_CONTINUE;
|
|
int count = 0;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_reset_quiesce_done;
|
|
|
|
for_each_hrrq(hrrq, ioa_cfg) {
|
|
spin_lock(&hrrq->_lock);
|
|
list_for_each_entry(loop_cmd, &hrrq->hrrq_pending_q, queue) {
|
|
count++;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
rc = IPR_RC_JOB_RETURN;
|
|
break;
|
|
}
|
|
spin_unlock(&hrrq->_lock);
|
|
|
|
if (count)
|
|
break;
|
|
}
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_cancel_hcam - Cancel outstanding HCAMs
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: Cancel any oustanding HCAMs to the IOA.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_cancel_hcam(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int rc = IPR_RC_JOB_CONTINUE;
|
|
struct ipr_cmd_pkt *cmd_pkt;
|
|
struct ipr_cmnd *hcam_cmd;
|
|
struct ipr_hrr_queue *hrrq = &ioa_cfg->hrrq[IPR_INIT_HRRQ];
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_reset_cancel_hcam_done;
|
|
|
|
if (!hrrq->ioa_is_dead) {
|
|
if (!list_empty(&ioa_cfg->hostrcb_pending_q)) {
|
|
list_for_each_entry(hcam_cmd, &hrrq->hrrq_pending_q, queue) {
|
|
if (hcam_cmd->ioarcb.cmd_pkt.cdb[0] != IPR_HOST_CONTROLLED_ASYNC)
|
|
continue;
|
|
|
|
ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt = &ipr_cmd->ioarcb.cmd_pkt;
|
|
cmd_pkt->request_type = IPR_RQTYPE_IOACMD;
|
|
cmd_pkt->cdb[0] = IPR_CANCEL_REQUEST;
|
|
cmd_pkt->cdb[1] = IPR_CANCEL_64BIT_IOARCB;
|
|
cmd_pkt->cdb[10] = ((u64) hcam_cmd->dma_addr >> 56) & 0xff;
|
|
cmd_pkt->cdb[11] = ((u64) hcam_cmd->dma_addr >> 48) & 0xff;
|
|
cmd_pkt->cdb[12] = ((u64) hcam_cmd->dma_addr >> 40) & 0xff;
|
|
cmd_pkt->cdb[13] = ((u64) hcam_cmd->dma_addr >> 32) & 0xff;
|
|
cmd_pkt->cdb[2] = ((u64) hcam_cmd->dma_addr >> 24) & 0xff;
|
|
cmd_pkt->cdb[3] = ((u64) hcam_cmd->dma_addr >> 16) & 0xff;
|
|
cmd_pkt->cdb[4] = ((u64) hcam_cmd->dma_addr >> 8) & 0xff;
|
|
cmd_pkt->cdb[5] = ((u64) hcam_cmd->dma_addr) & 0xff;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
|
|
IPR_CANCEL_TIMEOUT);
|
|
|
|
rc = IPR_RC_JOB_RETURN;
|
|
ipr_cmd->job_step = ipr_reset_cancel_hcam;
|
|
break;
|
|
}
|
|
}
|
|
} else
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_ucode_download_done - Microcode download completion
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function unmaps the microcode download buffer.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE
|
|
**/
|
|
static int ipr_reset_ucode_download_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
|
|
|
|
dma_unmap_sg(&ioa_cfg->pdev->dev, sglist->scatterlist,
|
|
sglist->num_sg, DMA_TO_DEVICE);
|
|
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
return IPR_RC_JOB_CONTINUE;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_ucode_download - Download microcode to the adapter
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function checks to see if it there is microcode
|
|
* to download to the adapter. If there is, a download is performed.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_ucode_download(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
struct ipr_sglist *sglist = ioa_cfg->ucode_sglist;
|
|
|
|
ENTER;
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
|
|
if (!sglist)
|
|
return IPR_RC_JOB_CONTINUE;
|
|
|
|
ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_SCSICDB;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[0] = WRITE_BUFFER;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_WR_BUF_DOWNLOAD_AND_SAVE;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[6] = (sglist->buffer_len & 0xff0000) >> 16;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[7] = (sglist->buffer_len & 0x00ff00) >> 8;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[8] = sglist->buffer_len & 0x0000ff;
|
|
|
|
if (ioa_cfg->sis64)
|
|
ipr_build_ucode_ioadl64(ipr_cmd, sglist);
|
|
else
|
|
ipr_build_ucode_ioadl(ipr_cmd, sglist);
|
|
ipr_cmd->job_step = ipr_reset_ucode_download_done;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout,
|
|
IPR_WRITE_BUFFER_TIMEOUT);
|
|
|
|
LEAVE;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_shutdown_ioa - Shutdown the adapter
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function issues an adapter shutdown of the
|
|
* specified type to the specified adapter as part of the
|
|
* adapter reset job.
|
|
*
|
|
* Return value:
|
|
* IPR_RC_JOB_CONTINUE / IPR_RC_JOB_RETURN
|
|
**/
|
|
static int ipr_reset_shutdown_ioa(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
enum ipr_shutdown_type shutdown_type = ipr_cmd->u.shutdown_type;
|
|
unsigned long timeout;
|
|
int rc = IPR_RC_JOB_CONTINUE;
|
|
|
|
ENTER;
|
|
if (shutdown_type == IPR_SHUTDOWN_QUIESCE)
|
|
ipr_cmd->job_step = ipr_reset_cancel_hcam;
|
|
else if (shutdown_type != IPR_SHUTDOWN_NONE &&
|
|
!ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead) {
|
|
ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[1] = shutdown_type;
|
|
|
|
if (shutdown_type == IPR_SHUTDOWN_NORMAL)
|
|
timeout = IPR_SHUTDOWN_TIMEOUT;
|
|
else if (shutdown_type == IPR_SHUTDOWN_PREPARE_FOR_NORMAL)
|
|
timeout = IPR_INTERNAL_TIMEOUT;
|
|
else if (ioa_cfg->dual_raid && ipr_dual_ioa_raid)
|
|
timeout = IPR_DUAL_IOA_ABBR_SHUTDOWN_TO;
|
|
else
|
|
timeout = IPR_ABBREV_SHUTDOWN_TIMEOUT;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_reset_ioa_job, ipr_timeout, timeout);
|
|
|
|
rc = IPR_RC_JOB_RETURN;
|
|
ipr_cmd->job_step = ipr_reset_ucode_download;
|
|
} else
|
|
ipr_cmd->job_step = ipr_reset_alert;
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_ioa_job - Adapter reset job
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: This function is the job router for the adapter reset job.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_reset_ioa_job(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
u32 rc, ioasc;
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
|
|
do {
|
|
ioasc = be32_to_cpu(ipr_cmd->s.ioasa.hdr.ioasc);
|
|
|
|
if (ioa_cfg->reset_cmd != ipr_cmd) {
|
|
/*
|
|
* We are doing nested adapter resets and this is
|
|
* not the current reset job.
|
|
*/
|
|
list_add_tail(&ipr_cmd->queue,
|
|
&ipr_cmd->hrrq->hrrq_free_q);
|
|
return;
|
|
}
|
|
|
|
if (IPR_IOASC_SENSE_KEY(ioasc)) {
|
|
rc = ipr_cmd->job_step_failed(ipr_cmd);
|
|
if (rc == IPR_RC_JOB_RETURN)
|
|
return;
|
|
}
|
|
|
|
ipr_reinit_ipr_cmnd(ipr_cmd);
|
|
ipr_cmd->job_step_failed = ipr_reset_cmd_failed;
|
|
rc = ipr_cmd->job_step(ipr_cmd);
|
|
} while (rc == IPR_RC_JOB_CONTINUE);
|
|
}
|
|
|
|
/**
|
|
* _ipr_initiate_ioa_reset - Initiate an adapter reset
|
|
* @ioa_cfg: ioa config struct
|
|
* @job_step: first job step of reset job
|
|
* @shutdown_type: shutdown type
|
|
*
|
|
* Description: This function will initiate the reset of the given adapter
|
|
* starting at the selected job step.
|
|
* If the caller needs to wait on the completion of the reset,
|
|
* the caller must sleep on the reset_wait_q.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void _ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
|
|
int (*job_step) (struct ipr_cmnd *),
|
|
enum ipr_shutdown_type shutdown_type)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
int i;
|
|
|
|
ioa_cfg->in_reset_reload = 1;
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].allow_cmds = 0;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
|
|
ioa_cfg->scsi_unblock = 0;
|
|
ioa_cfg->scsi_blocked = 1;
|
|
scsi_block_requests(ioa_cfg->host);
|
|
}
|
|
|
|
ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
ioa_cfg->reset_cmd = ipr_cmd;
|
|
ipr_cmd->job_step = job_step;
|
|
ipr_cmd->u.shutdown_type = shutdown_type;
|
|
|
|
ipr_reset_ioa_job(ipr_cmd);
|
|
}
|
|
|
|
/**
|
|
* ipr_initiate_ioa_reset - Initiate an adapter reset
|
|
* @ioa_cfg: ioa config struct
|
|
* @shutdown_type: shutdown type
|
|
*
|
|
* Description: This function will initiate the reset of the given adapter.
|
|
* If the caller needs to wait on the completion of the reset,
|
|
* the caller must sleep on the reset_wait_q.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_initiate_ioa_reset(struct ipr_ioa_cfg *ioa_cfg,
|
|
enum ipr_shutdown_type shutdown_type)
|
|
{
|
|
int i;
|
|
|
|
if (ioa_cfg->hrrq[IPR_INIT_HRRQ].ioa_is_dead)
|
|
return;
|
|
|
|
if (ioa_cfg->in_reset_reload) {
|
|
if (ioa_cfg->sdt_state == GET_DUMP)
|
|
ioa_cfg->sdt_state = WAIT_FOR_DUMP;
|
|
else if (ioa_cfg->sdt_state == READ_DUMP)
|
|
ioa_cfg->sdt_state = ABORT_DUMP;
|
|
}
|
|
|
|
if (ioa_cfg->reset_retries++ >= IPR_NUM_RESET_RELOAD_RETRIES) {
|
|
dev_err(&ioa_cfg->pdev->dev,
|
|
"IOA taken offline - error recovery failed\n");
|
|
|
|
ioa_cfg->reset_retries = 0;
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].ioa_is_dead = 1;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
|
|
if (ioa_cfg->in_ioa_bringdown) {
|
|
ioa_cfg->reset_cmd = NULL;
|
|
ioa_cfg->in_reset_reload = 0;
|
|
ipr_fail_all_ops(ioa_cfg);
|
|
wake_up_all(&ioa_cfg->reset_wait_q);
|
|
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].removing_ioa) {
|
|
ioa_cfg->scsi_unblock = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
}
|
|
return;
|
|
} else {
|
|
ioa_cfg->in_ioa_bringdown = 1;
|
|
shutdown_type = IPR_SHUTDOWN_NONE;
|
|
}
|
|
}
|
|
|
|
_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_shutdown_ioa,
|
|
shutdown_type);
|
|
}
|
|
|
|
/**
|
|
* ipr_reset_freeze - Hold off all I/O activity
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* Description: If the PCI slot is frozen, hold off all I/O
|
|
* activity; then, as soon as the slot is available again,
|
|
* initiate an adapter reset.
|
|
*/
|
|
static int ipr_reset_freeze(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = ipr_cmd->ioa_cfg;
|
|
int i;
|
|
|
|
/* Disallow new interrupts, avoid loop */
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].allow_interrupts = 0;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_pending_q);
|
|
ipr_cmd->done = ipr_reset_ioa_job;
|
|
return IPR_RC_JOB_RETURN;
|
|
}
|
|
|
|
/**
|
|
* ipr_pci_mmio_enabled - Called when MMIO has been re-enabled
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: This routine is called to tell us that the MMIO
|
|
* access to the IOA has been restored
|
|
*/
|
|
static pci_ers_result_t ipr_pci_mmio_enabled(struct pci_dev *pdev)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
if (!ioa_cfg->probe_done)
|
|
pci_save_state(pdev);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
return PCI_ERS_RESULT_NEED_RESET;
|
|
}
|
|
|
|
/**
|
|
* ipr_pci_frozen - Called when slot has experienced a PCI bus error.
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: This routine is called to tell us that the PCI bus
|
|
* is down. Can't do anything here, except put the device driver
|
|
* into a holding pattern, waiting for the PCI bus to come back.
|
|
*/
|
|
static void ipr_pci_frozen(struct pci_dev *pdev)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
if (ioa_cfg->probe_done)
|
|
_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_freeze, IPR_SHUTDOWN_NONE);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_pci_slot_reset - Called when PCI slot has been reset.
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: This routine is called by the pci error recovery
|
|
* code after the PCI slot has been reset, just before we
|
|
* should resume normal operations.
|
|
*/
|
|
static pci_ers_result_t ipr_pci_slot_reset(struct pci_dev *pdev)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
if (ioa_cfg->probe_done) {
|
|
if (ioa_cfg->needs_warm_reset)
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
else
|
|
_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_restore_cfg_space,
|
|
IPR_SHUTDOWN_NONE);
|
|
} else
|
|
wake_up_all(&ioa_cfg->eeh_wait_q);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
return PCI_ERS_RESULT_RECOVERED;
|
|
}
|
|
|
|
/**
|
|
* ipr_pci_perm_failure - Called when PCI slot is dead for good.
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: This routine is called when the PCI bus has
|
|
* permanently failed.
|
|
*/
|
|
static void ipr_pci_perm_failure(struct pci_dev *pdev)
|
|
{
|
|
unsigned long flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
int i;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
if (ioa_cfg->probe_done) {
|
|
if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
|
|
ioa_cfg->sdt_state = ABORT_DUMP;
|
|
ioa_cfg->reset_retries = IPR_NUM_RESET_RELOAD_RETRIES - 1;
|
|
ioa_cfg->in_ioa_bringdown = 1;
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].allow_cmds = 0;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
} else
|
|
wake_up_all(&ioa_cfg->eeh_wait_q);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
|
|
/**
|
|
* ipr_pci_error_detected - Called when a PCI error is detected.
|
|
* @pdev: PCI device struct
|
|
* @state: PCI channel state
|
|
*
|
|
* Description: Called when a PCI error is detected.
|
|
*
|
|
* Return value:
|
|
* PCI_ERS_RESULT_NEED_RESET or PCI_ERS_RESULT_DISCONNECT
|
|
*/
|
|
static pci_ers_result_t ipr_pci_error_detected(struct pci_dev *pdev,
|
|
pci_channel_state_t state)
|
|
{
|
|
switch (state) {
|
|
case pci_channel_io_frozen:
|
|
ipr_pci_frozen(pdev);
|
|
return PCI_ERS_RESULT_CAN_RECOVER;
|
|
case pci_channel_io_perm_failure:
|
|
ipr_pci_perm_failure(pdev);
|
|
return PCI_ERS_RESULT_DISCONNECT;
|
|
break;
|
|
default:
|
|
break;
|
|
}
|
|
return PCI_ERS_RESULT_NEED_RESET;
|
|
}
|
|
|
|
/**
|
|
* ipr_probe_ioa_part2 - Initializes IOAs found in ipr_probe_ioa(..)
|
|
* @ioa_cfg: ioa cfg struct
|
|
*
|
|
* Description: This is the second phase of adapter initialization
|
|
* This function takes care of initilizing the adapter to the point
|
|
* where it can accept new commands.
|
|
|
|
* Return value:
|
|
* 0 on success / -EIO on failure
|
|
**/
|
|
static int ipr_probe_ioa_part2(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int rc = 0;
|
|
unsigned long host_lock_flags = 0;
|
|
|
|
ENTER;
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
|
|
dev_dbg(&ioa_cfg->pdev->dev, "ioa_cfg adx: 0x%p\n", ioa_cfg);
|
|
ioa_cfg->probe_done = 1;
|
|
if (ioa_cfg->needs_hard_reset) {
|
|
ioa_cfg->needs_hard_reset = 0;
|
|
ipr_initiate_ioa_reset(ioa_cfg, IPR_SHUTDOWN_NONE);
|
|
} else
|
|
_ipr_initiate_ioa_reset(ioa_cfg, ipr_reset_enable_ioa,
|
|
IPR_SHUTDOWN_NONE);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
|
|
|
|
LEAVE;
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_free_cmd_blks - Frees command blocks allocated for an adapter
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_free_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int i;
|
|
|
|
if (ioa_cfg->ipr_cmnd_list) {
|
|
for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
|
|
if (ioa_cfg->ipr_cmnd_list[i])
|
|
dma_pool_free(ioa_cfg->ipr_cmd_pool,
|
|
ioa_cfg->ipr_cmnd_list[i],
|
|
ioa_cfg->ipr_cmnd_list_dma[i]);
|
|
|
|
ioa_cfg->ipr_cmnd_list[i] = NULL;
|
|
}
|
|
}
|
|
|
|
if (ioa_cfg->ipr_cmd_pool)
|
|
dma_pool_destroy(ioa_cfg->ipr_cmd_pool);
|
|
|
|
kfree(ioa_cfg->ipr_cmnd_list);
|
|
kfree(ioa_cfg->ipr_cmnd_list_dma);
|
|
ioa_cfg->ipr_cmnd_list = NULL;
|
|
ioa_cfg->ipr_cmnd_list_dma = NULL;
|
|
ioa_cfg->ipr_cmd_pool = NULL;
|
|
}
|
|
|
|
/**
|
|
* ipr_free_mem - Frees memory allocated for an adapter
|
|
* @ioa_cfg: ioa cfg struct
|
|
*
|
|
* Return value:
|
|
* nothing
|
|
**/
|
|
static void ipr_free_mem(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int i;
|
|
|
|
kfree(ioa_cfg->res_entries);
|
|
dma_free_coherent(&ioa_cfg->pdev->dev, sizeof(struct ipr_misc_cbs),
|
|
ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
|
|
ipr_free_cmd_blks(ioa_cfg);
|
|
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++)
|
|
dma_free_coherent(&ioa_cfg->pdev->dev,
|
|
sizeof(u32) * ioa_cfg->hrrq[i].size,
|
|
ioa_cfg->hrrq[i].host_rrq,
|
|
ioa_cfg->hrrq[i].host_rrq_dma);
|
|
|
|
dma_free_coherent(&ioa_cfg->pdev->dev, ioa_cfg->cfg_table_size,
|
|
ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
|
|
|
|
for (i = 0; i < IPR_MAX_HCAMS; i++) {
|
|
dma_free_coherent(&ioa_cfg->pdev->dev,
|
|
sizeof(struct ipr_hostrcb),
|
|
ioa_cfg->hostrcb[i],
|
|
ioa_cfg->hostrcb_dma[i]);
|
|
}
|
|
|
|
ipr_free_dump(ioa_cfg);
|
|
kfree(ioa_cfg->trace);
|
|
}
|
|
|
|
/**
|
|
* ipr_free_irqs - Free all allocated IRQs for the adapter.
|
|
* @ioa_cfg: ipr cfg struct
|
|
*
|
|
* This function frees all allocated IRQs for the
|
|
* specified adapter.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_free_irqs(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct pci_dev *pdev = ioa_cfg->pdev;
|
|
int i;
|
|
|
|
for (i = 0; i < ioa_cfg->nvectors; i++)
|
|
free_irq(pci_irq_vector(pdev, i), &ioa_cfg->hrrq[i]);
|
|
pci_free_irq_vectors(pdev);
|
|
}
|
|
|
|
/**
|
|
* ipr_free_all_resources - Free all allocated resources for an adapter.
|
|
* @ipr_cmd: ipr command struct
|
|
*
|
|
* This function frees all allocated resources for the
|
|
* specified adapter.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_free_all_resources(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct pci_dev *pdev = ioa_cfg->pdev;
|
|
|
|
ENTER;
|
|
ipr_free_irqs(ioa_cfg);
|
|
if (ioa_cfg->reset_work_q)
|
|
destroy_workqueue(ioa_cfg->reset_work_q);
|
|
iounmap(ioa_cfg->hdw_dma_regs);
|
|
pci_release_regions(pdev);
|
|
ipr_free_mem(ioa_cfg);
|
|
scsi_host_put(ioa_cfg->host);
|
|
pci_disable_device(pdev);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_alloc_cmd_blks - Allocate command blocks for an adapter
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / -ENOMEM on allocation failure
|
|
**/
|
|
static int ipr_alloc_cmd_blks(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioarcb *ioarcb;
|
|
dma_addr_t dma_addr;
|
|
int i, entries_each_hrrq, hrrq_id = 0;
|
|
|
|
ioa_cfg->ipr_cmd_pool = dma_pool_create(IPR_NAME, &ioa_cfg->pdev->dev,
|
|
sizeof(struct ipr_cmnd), 512, 0);
|
|
|
|
if (!ioa_cfg->ipr_cmd_pool)
|
|
return -ENOMEM;
|
|
|
|
ioa_cfg->ipr_cmnd_list = kcalloc(IPR_NUM_CMD_BLKS, sizeof(struct ipr_cmnd *), GFP_KERNEL);
|
|
ioa_cfg->ipr_cmnd_list_dma = kcalloc(IPR_NUM_CMD_BLKS, sizeof(dma_addr_t), GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->ipr_cmnd_list || !ioa_cfg->ipr_cmnd_list_dma) {
|
|
ipr_free_cmd_blks(ioa_cfg);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
if (ioa_cfg->hrrq_num > 1) {
|
|
if (i == 0) {
|
|
entries_each_hrrq = IPR_NUM_INTERNAL_CMD_BLKS;
|
|
ioa_cfg->hrrq[i].min_cmd_id = 0;
|
|
ioa_cfg->hrrq[i].max_cmd_id =
|
|
(entries_each_hrrq - 1);
|
|
} else {
|
|
entries_each_hrrq =
|
|
IPR_NUM_BASE_CMD_BLKS/
|
|
(ioa_cfg->hrrq_num - 1);
|
|
ioa_cfg->hrrq[i].min_cmd_id =
|
|
IPR_NUM_INTERNAL_CMD_BLKS +
|
|
(i - 1) * entries_each_hrrq;
|
|
ioa_cfg->hrrq[i].max_cmd_id =
|
|
(IPR_NUM_INTERNAL_CMD_BLKS +
|
|
i * entries_each_hrrq - 1);
|
|
}
|
|
} else {
|
|
entries_each_hrrq = IPR_NUM_CMD_BLKS;
|
|
ioa_cfg->hrrq[i].min_cmd_id = 0;
|
|
ioa_cfg->hrrq[i].max_cmd_id = (entries_each_hrrq - 1);
|
|
}
|
|
ioa_cfg->hrrq[i].size = entries_each_hrrq;
|
|
}
|
|
|
|
BUG_ON(ioa_cfg->hrrq_num == 0);
|
|
|
|
i = IPR_NUM_CMD_BLKS -
|
|
ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id - 1;
|
|
if (i > 0) {
|
|
ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].size += i;
|
|
ioa_cfg->hrrq[ioa_cfg->hrrq_num - 1].max_cmd_id += i;
|
|
}
|
|
|
|
for (i = 0; i < IPR_NUM_CMD_BLKS; i++) {
|
|
ipr_cmd = dma_pool_zalloc(ioa_cfg->ipr_cmd_pool,
|
|
GFP_KERNEL, &dma_addr);
|
|
|
|
if (!ipr_cmd) {
|
|
ipr_free_cmd_blks(ioa_cfg);
|
|
return -ENOMEM;
|
|
}
|
|
|
|
ioa_cfg->ipr_cmnd_list[i] = ipr_cmd;
|
|
ioa_cfg->ipr_cmnd_list_dma[i] = dma_addr;
|
|
|
|
ioarcb = &ipr_cmd->ioarcb;
|
|
ipr_cmd->dma_addr = dma_addr;
|
|
if (ioa_cfg->sis64)
|
|
ioarcb->a.ioarcb_host_pci_addr64 = cpu_to_be64(dma_addr);
|
|
else
|
|
ioarcb->a.ioarcb_host_pci_addr = cpu_to_be32(dma_addr);
|
|
|
|
ioarcb->host_response_handle = cpu_to_be32(i << 2);
|
|
if (ioa_cfg->sis64) {
|
|
ioarcb->u.sis64_addr_data.data_ioadl_addr =
|
|
cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, i.ioadl64));
|
|
ioarcb->u.sis64_addr_data.ioasa_host_pci_addr =
|
|
cpu_to_be64(dma_addr + offsetof(struct ipr_cmnd, s.ioasa64));
|
|
} else {
|
|
ioarcb->write_ioadl_addr =
|
|
cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, i.ioadl));
|
|
ioarcb->read_ioadl_addr = ioarcb->write_ioadl_addr;
|
|
ioarcb->ioasa_host_pci_addr =
|
|
cpu_to_be32(dma_addr + offsetof(struct ipr_cmnd, s.ioasa));
|
|
}
|
|
ioarcb->ioasa_len = cpu_to_be16(sizeof(struct ipr_ioasa));
|
|
ipr_cmd->cmd_index = i;
|
|
ipr_cmd->ioa_cfg = ioa_cfg;
|
|
ipr_cmd->sense_buffer_dma = dma_addr +
|
|
offsetof(struct ipr_cmnd, sense_buffer);
|
|
|
|
ipr_cmd->ioarcb.cmd_pkt.hrrq_id = hrrq_id;
|
|
ipr_cmd->hrrq = &ioa_cfg->hrrq[hrrq_id];
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
if (i >= ioa_cfg->hrrq[hrrq_id].max_cmd_id)
|
|
hrrq_id++;
|
|
}
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_alloc_mem - Allocate memory for an adapter
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero for error
|
|
**/
|
|
static int ipr_alloc_mem(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct pci_dev *pdev = ioa_cfg->pdev;
|
|
int i, rc = -ENOMEM;
|
|
|
|
ENTER;
|
|
ioa_cfg->res_entries = kcalloc(ioa_cfg->max_devs_supported,
|
|
sizeof(struct ipr_resource_entry),
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->res_entries)
|
|
goto out;
|
|
|
|
for (i = 0; i < ioa_cfg->max_devs_supported; i++) {
|
|
list_add_tail(&ioa_cfg->res_entries[i].queue, &ioa_cfg->free_res_q);
|
|
ioa_cfg->res_entries[i].ioa_cfg = ioa_cfg;
|
|
}
|
|
|
|
ioa_cfg->vpd_cbs = dma_alloc_coherent(&pdev->dev,
|
|
sizeof(struct ipr_misc_cbs),
|
|
&ioa_cfg->vpd_cbs_dma,
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->vpd_cbs)
|
|
goto out_free_res_entries;
|
|
|
|
if (ipr_alloc_cmd_blks(ioa_cfg))
|
|
goto out_free_vpd_cbs;
|
|
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
ioa_cfg->hrrq[i].host_rrq = dma_alloc_coherent(&pdev->dev,
|
|
sizeof(u32) * ioa_cfg->hrrq[i].size,
|
|
&ioa_cfg->hrrq[i].host_rrq_dma,
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->hrrq[i].host_rrq) {
|
|
while (--i > 0)
|
|
dma_free_coherent(&pdev->dev,
|
|
sizeof(u32) * ioa_cfg->hrrq[i].size,
|
|
ioa_cfg->hrrq[i].host_rrq,
|
|
ioa_cfg->hrrq[i].host_rrq_dma);
|
|
goto out_ipr_free_cmd_blocks;
|
|
}
|
|
ioa_cfg->hrrq[i].ioa_cfg = ioa_cfg;
|
|
}
|
|
|
|
ioa_cfg->u.cfg_table = dma_alloc_coherent(&pdev->dev,
|
|
ioa_cfg->cfg_table_size,
|
|
&ioa_cfg->cfg_table_dma,
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->u.cfg_table)
|
|
goto out_free_host_rrq;
|
|
|
|
for (i = 0; i < IPR_MAX_HCAMS; i++) {
|
|
ioa_cfg->hostrcb[i] = dma_alloc_coherent(&pdev->dev,
|
|
sizeof(struct ipr_hostrcb),
|
|
&ioa_cfg->hostrcb_dma[i],
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->hostrcb[i])
|
|
goto out_free_hostrcb_dma;
|
|
|
|
ioa_cfg->hostrcb[i]->hostrcb_dma =
|
|
ioa_cfg->hostrcb_dma[i] + offsetof(struct ipr_hostrcb, hcam);
|
|
ioa_cfg->hostrcb[i]->ioa_cfg = ioa_cfg;
|
|
list_add_tail(&ioa_cfg->hostrcb[i]->queue, &ioa_cfg->hostrcb_free_q);
|
|
}
|
|
|
|
ioa_cfg->trace = kcalloc(IPR_NUM_TRACE_ENTRIES,
|
|
sizeof(struct ipr_trace_entry),
|
|
GFP_KERNEL);
|
|
|
|
if (!ioa_cfg->trace)
|
|
goto out_free_hostrcb_dma;
|
|
|
|
rc = 0;
|
|
out:
|
|
LEAVE;
|
|
return rc;
|
|
|
|
out_free_hostrcb_dma:
|
|
while (i-- > 0) {
|
|
dma_free_coherent(&pdev->dev, sizeof(struct ipr_hostrcb),
|
|
ioa_cfg->hostrcb[i],
|
|
ioa_cfg->hostrcb_dma[i]);
|
|
}
|
|
dma_free_coherent(&pdev->dev, ioa_cfg->cfg_table_size,
|
|
ioa_cfg->u.cfg_table, ioa_cfg->cfg_table_dma);
|
|
out_free_host_rrq:
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
dma_free_coherent(&pdev->dev,
|
|
sizeof(u32) * ioa_cfg->hrrq[i].size,
|
|
ioa_cfg->hrrq[i].host_rrq,
|
|
ioa_cfg->hrrq[i].host_rrq_dma);
|
|
}
|
|
out_ipr_free_cmd_blocks:
|
|
ipr_free_cmd_blks(ioa_cfg);
|
|
out_free_vpd_cbs:
|
|
dma_free_coherent(&pdev->dev, sizeof(struct ipr_misc_cbs),
|
|
ioa_cfg->vpd_cbs, ioa_cfg->vpd_cbs_dma);
|
|
out_free_res_entries:
|
|
kfree(ioa_cfg->res_entries);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* ipr_initialize_bus_attr - Initialize SCSI bus attributes to default values
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_initialize_bus_attr(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < IPR_MAX_NUM_BUSES; i++) {
|
|
ioa_cfg->bus_attr[i].bus = i;
|
|
ioa_cfg->bus_attr[i].qas_enabled = 0;
|
|
ioa_cfg->bus_attr[i].bus_width = IPR_DEFAULT_BUS_WIDTH;
|
|
if (ipr_max_speed < ARRAY_SIZE(ipr_max_bus_speeds))
|
|
ioa_cfg->bus_attr[i].max_xfer_rate = ipr_max_bus_speeds[ipr_max_speed];
|
|
else
|
|
ioa_cfg->bus_attr[i].max_xfer_rate = IPR_U160_SCSI_RATE;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_init_regs - Initialize IOA registers
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_init_regs(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
const struct ipr_interrupt_offsets *p;
|
|
struct ipr_interrupts *t;
|
|
void __iomem *base;
|
|
|
|
p = &ioa_cfg->chip_cfg->regs;
|
|
t = &ioa_cfg->regs;
|
|
base = ioa_cfg->hdw_dma_regs;
|
|
|
|
t->set_interrupt_mask_reg = base + p->set_interrupt_mask_reg;
|
|
t->clr_interrupt_mask_reg = base + p->clr_interrupt_mask_reg;
|
|
t->clr_interrupt_mask_reg32 = base + p->clr_interrupt_mask_reg32;
|
|
t->sense_interrupt_mask_reg = base + p->sense_interrupt_mask_reg;
|
|
t->sense_interrupt_mask_reg32 = base + p->sense_interrupt_mask_reg32;
|
|
t->clr_interrupt_reg = base + p->clr_interrupt_reg;
|
|
t->clr_interrupt_reg32 = base + p->clr_interrupt_reg32;
|
|
t->sense_interrupt_reg = base + p->sense_interrupt_reg;
|
|
t->sense_interrupt_reg32 = base + p->sense_interrupt_reg32;
|
|
t->ioarrin_reg = base + p->ioarrin_reg;
|
|
t->sense_uproc_interrupt_reg = base + p->sense_uproc_interrupt_reg;
|
|
t->sense_uproc_interrupt_reg32 = base + p->sense_uproc_interrupt_reg32;
|
|
t->set_uproc_interrupt_reg = base + p->set_uproc_interrupt_reg;
|
|
t->set_uproc_interrupt_reg32 = base + p->set_uproc_interrupt_reg32;
|
|
t->clr_uproc_interrupt_reg = base + p->clr_uproc_interrupt_reg;
|
|
t->clr_uproc_interrupt_reg32 = base + p->clr_uproc_interrupt_reg32;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
t->init_feedback_reg = base + p->init_feedback_reg;
|
|
t->dump_addr_reg = base + p->dump_addr_reg;
|
|
t->dump_data_reg = base + p->dump_data_reg;
|
|
t->endian_swap_reg = base + p->endian_swap_reg;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_init_ioa_cfg - Initialize IOA config struct
|
|
* @ioa_cfg: ioa config struct
|
|
* @host: scsi host struct
|
|
* @pdev: PCI dev struct
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_init_ioa_cfg(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct Scsi_Host *host, struct pci_dev *pdev)
|
|
{
|
|
int i;
|
|
|
|
ioa_cfg->host = host;
|
|
ioa_cfg->pdev = pdev;
|
|
ioa_cfg->log_level = ipr_log_level;
|
|
ioa_cfg->doorbell = IPR_DOORBELL;
|
|
sprintf(ioa_cfg->eye_catcher, IPR_EYECATCHER);
|
|
sprintf(ioa_cfg->trace_start, IPR_TRACE_START_LABEL);
|
|
sprintf(ioa_cfg->cfg_table_start, IPR_CFG_TBL_START);
|
|
sprintf(ioa_cfg->resource_table_label, IPR_RES_TABLE_LABEL);
|
|
sprintf(ioa_cfg->ipr_hcam_label, IPR_HCAM_LABEL);
|
|
sprintf(ioa_cfg->ipr_cmd_label, IPR_CMD_LABEL);
|
|
|
|
INIT_LIST_HEAD(&ioa_cfg->hostrcb_free_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->hostrcb_pending_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->hostrcb_report_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->free_res_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->used_res_q);
|
|
INIT_WORK(&ioa_cfg->work_q, ipr_worker_thread);
|
|
INIT_WORK(&ioa_cfg->scsi_add_work_q, ipr_add_remove_thread);
|
|
init_waitqueue_head(&ioa_cfg->reset_wait_q);
|
|
init_waitqueue_head(&ioa_cfg->msi_wait_q);
|
|
init_waitqueue_head(&ioa_cfg->eeh_wait_q);
|
|
ioa_cfg->sdt_state = INACTIVE;
|
|
|
|
ipr_initialize_bus_attr(ioa_cfg);
|
|
ioa_cfg->max_devs_supported = ipr_max_devs;
|
|
|
|
if (ioa_cfg->sis64) {
|
|
host->max_id = IPR_MAX_SIS64_TARGETS_PER_BUS;
|
|
host->max_lun = IPR_MAX_SIS64_LUNS_PER_TARGET;
|
|
if (ipr_max_devs > IPR_MAX_SIS64_DEVS)
|
|
ioa_cfg->max_devs_supported = IPR_MAX_SIS64_DEVS;
|
|
ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr64)
|
|
+ ((sizeof(struct ipr_config_table_entry64)
|
|
* ioa_cfg->max_devs_supported)));
|
|
} else {
|
|
host->max_id = IPR_MAX_NUM_TARGETS_PER_BUS;
|
|
host->max_lun = IPR_MAX_NUM_LUNS_PER_TARGET;
|
|
if (ipr_max_devs > IPR_MAX_PHYSICAL_DEVS)
|
|
ioa_cfg->max_devs_supported = IPR_MAX_PHYSICAL_DEVS;
|
|
ioa_cfg->cfg_table_size = (sizeof(struct ipr_config_table_hdr)
|
|
+ ((sizeof(struct ipr_config_table_entry)
|
|
* ioa_cfg->max_devs_supported)));
|
|
}
|
|
|
|
host->max_channel = IPR_VSET_BUS;
|
|
host->unique_id = host->host_no;
|
|
host->max_cmd_len = IPR_MAX_CDB_LEN;
|
|
host->can_queue = ioa_cfg->max_cmds;
|
|
pci_set_drvdata(pdev, ioa_cfg);
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ioa_cfg->hrrq); i++) {
|
|
INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_free_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->hrrq[i].hrrq_pending_q);
|
|
spin_lock_init(&ioa_cfg->hrrq[i]._lock);
|
|
if (i == 0)
|
|
ioa_cfg->hrrq[i].lock = ioa_cfg->host->host_lock;
|
|
else
|
|
ioa_cfg->hrrq[i].lock = &ioa_cfg->hrrq[i]._lock;
|
|
}
|
|
}
|
|
|
|
/**
|
|
* ipr_get_chip_info - Find adapter chip information
|
|
* @dev_id: PCI device id struct
|
|
*
|
|
* Return value:
|
|
* ptr to chip information on success / NULL on failure
|
|
**/
|
|
static const struct ipr_chip_t *
|
|
ipr_get_chip_info(const struct pci_device_id *dev_id)
|
|
{
|
|
int i;
|
|
|
|
for (i = 0; i < ARRAY_SIZE(ipr_chip); i++)
|
|
if (ipr_chip[i].vendor == dev_id->vendor &&
|
|
ipr_chip[i].device == dev_id->device)
|
|
return &ipr_chip[i];
|
|
return NULL;
|
|
}
|
|
|
|
/**
|
|
* ipr_wait_for_pci_err_recovery - Wait for any PCI error recovery to complete
|
|
* during probe time
|
|
* @ioa_cfg: ioa config struct
|
|
*
|
|
* Return value:
|
|
* None
|
|
**/
|
|
static void ipr_wait_for_pci_err_recovery(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
struct pci_dev *pdev = ioa_cfg->pdev;
|
|
|
|
if (pci_channel_offline(pdev)) {
|
|
wait_event_timeout(ioa_cfg->eeh_wait_q,
|
|
!pci_channel_offline(pdev),
|
|
IPR_PCI_ERROR_RECOVERY_TIMEOUT);
|
|
pci_restore_state(pdev);
|
|
}
|
|
}
|
|
|
|
static void name_msi_vectors(struct ipr_ioa_cfg *ioa_cfg)
|
|
{
|
|
int vec_idx, n = sizeof(ioa_cfg->vectors_info[0].desc) - 1;
|
|
|
|
for (vec_idx = 0; vec_idx < ioa_cfg->nvectors; vec_idx++) {
|
|
snprintf(ioa_cfg->vectors_info[vec_idx].desc, n,
|
|
"host%d-%d", ioa_cfg->host->host_no, vec_idx);
|
|
ioa_cfg->vectors_info[vec_idx].
|
|
desc[strlen(ioa_cfg->vectors_info[vec_idx].desc)] = 0;
|
|
}
|
|
}
|
|
|
|
static int ipr_request_other_msi_irqs(struct ipr_ioa_cfg *ioa_cfg,
|
|
struct pci_dev *pdev)
|
|
{
|
|
int i, rc;
|
|
|
|
for (i = 1; i < ioa_cfg->nvectors; i++) {
|
|
rc = request_irq(pci_irq_vector(pdev, i),
|
|
ipr_isr_mhrrq,
|
|
0,
|
|
ioa_cfg->vectors_info[i].desc,
|
|
&ioa_cfg->hrrq[i]);
|
|
if (rc) {
|
|
while (--i >= 0)
|
|
free_irq(pci_irq_vector(pdev, i),
|
|
&ioa_cfg->hrrq[i]);
|
|
return rc;
|
|
}
|
|
}
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_test_intr - Handle the interrupt generated in ipr_test_msi().
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: Simply set the msi_received flag to 1 indicating that
|
|
* Message Signaled Interrupts are supported.
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static irqreturn_t ipr_test_intr(int irq, void *devp)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = (struct ipr_ioa_cfg *)devp;
|
|
unsigned long lock_flags = 0;
|
|
irqreturn_t rc = IRQ_HANDLED;
|
|
|
|
dev_info(&ioa_cfg->pdev->dev, "Received IRQ : %d\n", irq);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
ioa_cfg->msi_received = 1;
|
|
wake_up(&ioa_cfg->msi_wait_q);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
return rc;
|
|
}
|
|
|
|
/**
|
|
* ipr_test_msi - Test for Message Signaled Interrupt (MSI) support.
|
|
* @pdev: PCI device struct
|
|
*
|
|
* Description: This routine sets up and initiates a test interrupt to determine
|
|
* if the interrupt is received via the ipr_test_intr() service routine.
|
|
* If the tests fails, the driver will fall back to LSI.
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static int ipr_test_msi(struct ipr_ioa_cfg *ioa_cfg, struct pci_dev *pdev)
|
|
{
|
|
int rc;
|
|
volatile u32 int_reg;
|
|
unsigned long lock_flags = 0;
|
|
int irq = pci_irq_vector(pdev, 0);
|
|
|
|
ENTER;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
init_waitqueue_head(&ioa_cfg->msi_wait_q);
|
|
ioa_cfg->msi_received = 0;
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
|
|
writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.clr_interrupt_mask_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_mask_reg);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
rc = request_irq(irq, ipr_test_intr, 0, IPR_NAME, ioa_cfg);
|
|
if (rc) {
|
|
dev_err(&pdev->dev, "Can not assign irq %d\n", irq);
|
|
return rc;
|
|
} else if (ipr_debug)
|
|
dev_info(&pdev->dev, "IRQ assigned: %d\n", irq);
|
|
|
|
writel(IPR_PCII_IO_DEBUG_ACKNOWLEDGE, ioa_cfg->regs.sense_interrupt_reg32);
|
|
int_reg = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
wait_event_timeout(ioa_cfg->msi_wait_q, ioa_cfg->msi_received, HZ);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
|
|
|
|
if (!ioa_cfg->msi_received) {
|
|
/* MSI test failed */
|
|
dev_info(&pdev->dev, "MSI test failed. Falling back to LSI.\n");
|
|
rc = -EOPNOTSUPP;
|
|
} else if (ipr_debug)
|
|
dev_info(&pdev->dev, "MSI test succeeded.\n");
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
free_irq(irq, ioa_cfg);
|
|
|
|
LEAVE;
|
|
|
|
return rc;
|
|
}
|
|
|
|
/* ipr_probe_ioa - Allocates memory and does first stage of initialization
|
|
* @pdev: PCI device struct
|
|
* @dev_id: PCI device id struct
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static int ipr_probe_ioa(struct pci_dev *pdev,
|
|
const struct pci_device_id *dev_id)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
struct Scsi_Host *host;
|
|
unsigned long ipr_regs_pci;
|
|
void __iomem *ipr_regs;
|
|
int rc = PCIBIOS_SUCCESSFUL;
|
|
volatile u32 mask, uproc, interrupts;
|
|
unsigned long lock_flags, driver_lock_flags;
|
|
unsigned int irq_flag;
|
|
|
|
ENTER;
|
|
|
|
dev_info(&pdev->dev, "Found IOA with IRQ: %d\n", pdev->irq);
|
|
host = scsi_host_alloc(&driver_template, sizeof(*ioa_cfg));
|
|
|
|
if (!host) {
|
|
dev_err(&pdev->dev, "call to scsi_host_alloc failed!\n");
|
|
rc = -ENOMEM;
|
|
goto out;
|
|
}
|
|
|
|
ioa_cfg = (struct ipr_ioa_cfg *)host->hostdata;
|
|
memset(ioa_cfg, 0, sizeof(struct ipr_ioa_cfg));
|
|
ata_host_init(&ioa_cfg->ata_host, &pdev->dev, &ipr_sata_ops);
|
|
|
|
ioa_cfg->ipr_chip = ipr_get_chip_info(dev_id);
|
|
|
|
if (!ioa_cfg->ipr_chip) {
|
|
dev_err(&pdev->dev, "Unknown adapter chipset 0x%04X 0x%04X\n",
|
|
dev_id->vendor, dev_id->device);
|
|
goto out_scsi_host_put;
|
|
}
|
|
|
|
/* set SIS 32 or SIS 64 */
|
|
ioa_cfg->sis64 = ioa_cfg->ipr_chip->sis_type == IPR_SIS64 ? 1 : 0;
|
|
ioa_cfg->chip_cfg = ioa_cfg->ipr_chip->cfg;
|
|
ioa_cfg->clear_isr = ioa_cfg->chip_cfg->clear_isr;
|
|
ioa_cfg->max_cmds = ioa_cfg->chip_cfg->max_cmds;
|
|
|
|
if (ipr_transop_timeout)
|
|
ioa_cfg->transop_timeout = ipr_transop_timeout;
|
|
else if (dev_id->driver_data & IPR_USE_LONG_TRANSOP_TIMEOUT)
|
|
ioa_cfg->transop_timeout = IPR_LONG_OPERATIONAL_TIMEOUT;
|
|
else
|
|
ioa_cfg->transop_timeout = IPR_OPERATIONAL_TIMEOUT;
|
|
|
|
ioa_cfg->revid = pdev->revision;
|
|
|
|
ipr_init_ioa_cfg(ioa_cfg, host, pdev);
|
|
|
|
ipr_regs_pci = pci_resource_start(pdev, 0);
|
|
|
|
rc = pci_request_regions(pdev, IPR_NAME);
|
|
if (rc < 0) {
|
|
dev_err(&pdev->dev,
|
|
"Couldn't register memory range of registers\n");
|
|
goto out_scsi_host_put;
|
|
}
|
|
|
|
rc = pci_enable_device(pdev);
|
|
|
|
if (rc || pci_channel_offline(pdev)) {
|
|
if (pci_channel_offline(pdev)) {
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
rc = pci_enable_device(pdev);
|
|
}
|
|
|
|
if (rc) {
|
|
dev_err(&pdev->dev, "Cannot enable adapter\n");
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
goto out_release_regions;
|
|
}
|
|
}
|
|
|
|
ipr_regs = pci_ioremap_bar(pdev, 0);
|
|
|
|
if (!ipr_regs) {
|
|
dev_err(&pdev->dev,
|
|
"Couldn't map memory range of registers\n");
|
|
rc = -ENOMEM;
|
|
goto out_disable;
|
|
}
|
|
|
|
ioa_cfg->hdw_dma_regs = ipr_regs;
|
|
ioa_cfg->hdw_dma_regs_pci = ipr_regs_pci;
|
|
ioa_cfg->ioa_mailbox = ioa_cfg->chip_cfg->mailbox + ipr_regs;
|
|
|
|
ipr_init_regs(ioa_cfg);
|
|
|
|
if (ioa_cfg->sis64) {
|
|
rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(64));
|
|
if (rc < 0) {
|
|
dev_dbg(&pdev->dev, "Failed to set 64 bit DMA mask\n");
|
|
rc = dma_set_mask_and_coherent(&pdev->dev,
|
|
DMA_BIT_MASK(32));
|
|
}
|
|
} else
|
|
rc = dma_set_mask_and_coherent(&pdev->dev, DMA_BIT_MASK(32));
|
|
|
|
if (rc < 0) {
|
|
dev_err(&pdev->dev, "Failed to set DMA mask\n");
|
|
goto cleanup_nomem;
|
|
}
|
|
|
|
rc = pci_write_config_byte(pdev, PCI_CACHE_LINE_SIZE,
|
|
ioa_cfg->chip_cfg->cache_line_size);
|
|
|
|
if (rc != PCIBIOS_SUCCESSFUL) {
|
|
dev_err(&pdev->dev, "Write of cache line size failed\n");
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
rc = -EIO;
|
|
goto cleanup_nomem;
|
|
}
|
|
|
|
/* Issue MMIO read to ensure card is not in EEH */
|
|
interrupts = readl(ioa_cfg->regs.sense_interrupt_reg);
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
|
|
if (ipr_number_of_msix > IPR_MAX_MSIX_VECTORS) {
|
|
dev_err(&pdev->dev, "The max number of MSIX is %d\n",
|
|
IPR_MAX_MSIX_VECTORS);
|
|
ipr_number_of_msix = IPR_MAX_MSIX_VECTORS;
|
|
}
|
|
|
|
irq_flag = PCI_IRQ_LEGACY;
|
|
if (ioa_cfg->ipr_chip->has_msi)
|
|
irq_flag |= PCI_IRQ_MSI | PCI_IRQ_MSIX;
|
|
rc = pci_alloc_irq_vectors(pdev, 1, ipr_number_of_msix, irq_flag);
|
|
if (rc < 0) {
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
goto cleanup_nomem;
|
|
}
|
|
ioa_cfg->nvectors = rc;
|
|
|
|
if (!pdev->msi_enabled && !pdev->msix_enabled)
|
|
ioa_cfg->clear_isr = 1;
|
|
|
|
pci_set_master(pdev);
|
|
|
|
if (pci_channel_offline(pdev)) {
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
pci_set_master(pdev);
|
|
if (pci_channel_offline(pdev)) {
|
|
rc = -EIO;
|
|
goto out_msi_disable;
|
|
}
|
|
}
|
|
|
|
if (pdev->msi_enabled || pdev->msix_enabled) {
|
|
rc = ipr_test_msi(ioa_cfg, pdev);
|
|
switch (rc) {
|
|
case 0:
|
|
dev_info(&pdev->dev,
|
|
"Request for %d MSI%ss succeeded.", ioa_cfg->nvectors,
|
|
pdev->msix_enabled ? "-X" : "");
|
|
break;
|
|
case -EOPNOTSUPP:
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
pci_free_irq_vectors(pdev);
|
|
|
|
ioa_cfg->nvectors = 1;
|
|
ioa_cfg->clear_isr = 1;
|
|
break;
|
|
default:
|
|
goto out_msi_disable;
|
|
}
|
|
}
|
|
|
|
ioa_cfg->hrrq_num = min3(ioa_cfg->nvectors,
|
|
(unsigned int)num_online_cpus(),
|
|
(unsigned int)IPR_MAX_HRRQ_NUM);
|
|
|
|
if ((rc = ipr_save_pcix_cmd_reg(ioa_cfg)))
|
|
goto out_msi_disable;
|
|
|
|
if ((rc = ipr_set_pcix_cmd_reg(ioa_cfg)))
|
|
goto out_msi_disable;
|
|
|
|
rc = ipr_alloc_mem(ioa_cfg);
|
|
if (rc < 0) {
|
|
dev_err(&pdev->dev,
|
|
"Couldn't allocate enough memory for device driver!\n");
|
|
goto out_msi_disable;
|
|
}
|
|
|
|
/* Save away PCI config space for use following IOA reset */
|
|
rc = pci_save_state(pdev);
|
|
|
|
if (rc != PCIBIOS_SUCCESSFUL) {
|
|
dev_err(&pdev->dev, "Failed to save PCI config space\n");
|
|
rc = -EIO;
|
|
goto cleanup_nolog;
|
|
}
|
|
|
|
/*
|
|
* If HRRQ updated interrupt is not masked, or reset alert is set,
|
|
* the card is in an unknown state and needs a hard reset
|
|
*/
|
|
mask = readl(ioa_cfg->regs.sense_interrupt_mask_reg32);
|
|
interrupts = readl(ioa_cfg->regs.sense_interrupt_reg32);
|
|
uproc = readl(ioa_cfg->regs.sense_uproc_interrupt_reg32);
|
|
if ((mask & IPR_PCII_HRRQ_UPDATED) == 0 || (uproc & IPR_UPROCI_RESET_ALERT))
|
|
ioa_cfg->needs_hard_reset = 1;
|
|
if ((interrupts & IPR_PCII_ERROR_INTERRUPTS) || reset_devices)
|
|
ioa_cfg->needs_hard_reset = 1;
|
|
if (interrupts & IPR_PCII_IOA_UNIT_CHECKED)
|
|
ioa_cfg->ioa_unit_checked = 1;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
ipr_mask_and_clear_interrupts(ioa_cfg, ~IPR_PCII_IOA_TRANS_TO_OPER);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
|
|
if (pdev->msi_enabled || pdev->msix_enabled) {
|
|
name_msi_vectors(ioa_cfg);
|
|
rc = request_irq(pci_irq_vector(pdev, 0), ipr_isr, 0,
|
|
ioa_cfg->vectors_info[0].desc,
|
|
&ioa_cfg->hrrq[0]);
|
|
if (!rc)
|
|
rc = ipr_request_other_msi_irqs(ioa_cfg, pdev);
|
|
} else {
|
|
rc = request_irq(pdev->irq, ipr_isr,
|
|
IRQF_SHARED,
|
|
IPR_NAME, &ioa_cfg->hrrq[0]);
|
|
}
|
|
if (rc) {
|
|
dev_err(&pdev->dev, "Couldn't register IRQ %d! rc=%d\n",
|
|
pdev->irq, rc);
|
|
goto cleanup_nolog;
|
|
}
|
|
|
|
if ((dev_id->driver_data & IPR_USE_PCI_WARM_RESET) ||
|
|
(dev_id->device == PCI_DEVICE_ID_IBM_OBSIDIAN_E && !ioa_cfg->revid)) {
|
|
ioa_cfg->needs_warm_reset = 1;
|
|
ioa_cfg->reset = ipr_reset_slot_reset;
|
|
|
|
ioa_cfg->reset_work_q = alloc_ordered_workqueue("ipr_reset_%d",
|
|
WQ_MEM_RECLAIM, host->host_no);
|
|
|
|
if (!ioa_cfg->reset_work_q) {
|
|
dev_err(&pdev->dev, "Couldn't register reset workqueue\n");
|
|
rc = -ENOMEM;
|
|
goto out_free_irq;
|
|
}
|
|
} else
|
|
ioa_cfg->reset = ipr_reset_start_bist;
|
|
|
|
spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
|
|
list_add_tail(&ioa_cfg->queue, &ipr_ioa_head);
|
|
spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
|
|
|
|
LEAVE;
|
|
out:
|
|
return rc;
|
|
|
|
out_free_irq:
|
|
ipr_free_irqs(ioa_cfg);
|
|
cleanup_nolog:
|
|
ipr_free_mem(ioa_cfg);
|
|
out_msi_disable:
|
|
ipr_wait_for_pci_err_recovery(ioa_cfg);
|
|
pci_free_irq_vectors(pdev);
|
|
cleanup_nomem:
|
|
iounmap(ipr_regs);
|
|
out_disable:
|
|
pci_disable_device(pdev);
|
|
out_release_regions:
|
|
pci_release_regions(pdev);
|
|
out_scsi_host_put:
|
|
scsi_host_put(host);
|
|
goto out;
|
|
}
|
|
|
|
/**
|
|
* ipr_initiate_ioa_bringdown - Bring down an adapter
|
|
* @ioa_cfg: ioa config struct
|
|
* @shutdown_type: shutdown type
|
|
*
|
|
* Description: This function will initiate bringing down the adapter.
|
|
* This consists of issuing an IOA shutdown to the adapter
|
|
* to flush the cache, and running BIST.
|
|
* If the caller needs to wait on the completion of the reset,
|
|
* the caller must sleep on the reset_wait_q.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_initiate_ioa_bringdown(struct ipr_ioa_cfg *ioa_cfg,
|
|
enum ipr_shutdown_type shutdown_type)
|
|
{
|
|
ENTER;
|
|
if (ioa_cfg->sdt_state == WAIT_FOR_DUMP)
|
|
ioa_cfg->sdt_state = ABORT_DUMP;
|
|
ioa_cfg->reset_retries = 0;
|
|
ioa_cfg->in_ioa_bringdown = 1;
|
|
ipr_initiate_ioa_reset(ioa_cfg, shutdown_type);
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* __ipr_remove - Remove a single adapter
|
|
* @pdev: pci device struct
|
|
*
|
|
* Adapter hot plug remove entry point.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void __ipr_remove(struct pci_dev *pdev)
|
|
{
|
|
unsigned long host_lock_flags = 0;
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
int i;
|
|
unsigned long driver_lock_flags;
|
|
ENTER;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
|
|
}
|
|
|
|
for (i = 0; i < ioa_cfg->hrrq_num; i++) {
|
|
spin_lock(&ioa_cfg->hrrq[i]._lock);
|
|
ioa_cfg->hrrq[i].removing_ioa = 1;
|
|
spin_unlock(&ioa_cfg->hrrq[i]._lock);
|
|
}
|
|
wmb();
|
|
ipr_initiate_ioa_bringdown(ioa_cfg, IPR_SHUTDOWN_NORMAL);
|
|
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
flush_work(&ioa_cfg->work_q);
|
|
if (ioa_cfg->reset_work_q)
|
|
flush_workqueue(ioa_cfg->reset_work_q);
|
|
INIT_LIST_HEAD(&ioa_cfg->used_res_q);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, host_lock_flags);
|
|
|
|
spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
|
|
list_del(&ioa_cfg->queue);
|
|
spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
|
|
|
|
if (ioa_cfg->sdt_state == ABORT_DUMP)
|
|
ioa_cfg->sdt_state = WAIT_FOR_DUMP;
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, host_lock_flags);
|
|
|
|
ipr_free_all_resources(ioa_cfg);
|
|
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_remove - IOA hot plug remove entry point
|
|
* @pdev: pci device struct
|
|
*
|
|
* Adapter hot plug remove entry point.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_remove(struct pci_dev *pdev)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
|
|
ENTER;
|
|
|
|
ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_trace_attr);
|
|
ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_dump_attr);
|
|
sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_ioa_async_err_log);
|
|
scsi_remove_host(ioa_cfg->host);
|
|
|
|
__ipr_remove(pdev);
|
|
|
|
LEAVE;
|
|
}
|
|
|
|
/**
|
|
* ipr_probe - Adapter hot plug add entry point
|
|
*
|
|
* Return value:
|
|
* 0 on success / non-zero on failure
|
|
**/
|
|
static int ipr_probe(struct pci_dev *pdev, const struct pci_device_id *dev_id)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
unsigned long flags;
|
|
int rc, i;
|
|
|
|
rc = ipr_probe_ioa(pdev, dev_id);
|
|
|
|
if (rc)
|
|
return rc;
|
|
|
|
ioa_cfg = pci_get_drvdata(pdev);
|
|
rc = ipr_probe_ioa_part2(ioa_cfg);
|
|
|
|
if (rc) {
|
|
__ipr_remove(pdev);
|
|
return rc;
|
|
}
|
|
|
|
rc = scsi_add_host(ioa_cfg->host, &pdev->dev);
|
|
|
|
if (rc) {
|
|
__ipr_remove(pdev);
|
|
return rc;
|
|
}
|
|
|
|
rc = ipr_create_trace_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_trace_attr);
|
|
|
|
if (rc) {
|
|
scsi_remove_host(ioa_cfg->host);
|
|
__ipr_remove(pdev);
|
|
return rc;
|
|
}
|
|
|
|
rc = sysfs_create_bin_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_ioa_async_err_log);
|
|
|
|
if (rc) {
|
|
ipr_remove_dump_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_dump_attr);
|
|
ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_trace_attr);
|
|
scsi_remove_host(ioa_cfg->host);
|
|
__ipr_remove(pdev);
|
|
return rc;
|
|
}
|
|
|
|
rc = ipr_create_dump_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_dump_attr);
|
|
|
|
if (rc) {
|
|
sysfs_remove_bin_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_ioa_async_err_log);
|
|
ipr_remove_trace_file(&ioa_cfg->host->shost_dev.kobj,
|
|
&ipr_trace_attr);
|
|
scsi_remove_host(ioa_cfg->host);
|
|
__ipr_remove(pdev);
|
|
return rc;
|
|
}
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
ioa_cfg->scan_enabled = 1;
|
|
schedule_work(&ioa_cfg->work_q);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
|
|
ioa_cfg->iopoll_weight = ioa_cfg->chip_cfg->iopoll_weight;
|
|
|
|
if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
|
|
for (i = 1; i < ioa_cfg->hrrq_num; i++) {
|
|
irq_poll_init(&ioa_cfg->hrrq[i].iopoll,
|
|
ioa_cfg->iopoll_weight, ipr_iopoll);
|
|
}
|
|
}
|
|
|
|
scsi_scan_host(ioa_cfg->host);
|
|
|
|
return 0;
|
|
}
|
|
|
|
/**
|
|
* ipr_shutdown - Shutdown handler.
|
|
* @pdev: pci device struct
|
|
*
|
|
* This function is invoked upon system shutdown/reboot. It will issue
|
|
* an adapter shutdown to the adapter to flush the write cache.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_shutdown(struct pci_dev *pdev)
|
|
{
|
|
struct ipr_ioa_cfg *ioa_cfg = pci_get_drvdata(pdev);
|
|
unsigned long lock_flags = 0;
|
|
enum ipr_shutdown_type shutdown_type = IPR_SHUTDOWN_NORMAL;
|
|
int i;
|
|
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
if (ioa_cfg->iopoll_weight && ioa_cfg->sis64 && ioa_cfg->nvectors > 1) {
|
|
ioa_cfg->iopoll_weight = 0;
|
|
for (i = 1; i < ioa_cfg->hrrq_num; i++)
|
|
irq_poll_disable(&ioa_cfg->hrrq[i].iopoll);
|
|
}
|
|
|
|
while (ioa_cfg->in_reset_reload) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, lock_flags);
|
|
}
|
|
|
|
if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64)
|
|
shutdown_type = IPR_SHUTDOWN_QUIESCE;
|
|
|
|
ipr_initiate_ioa_bringdown(ioa_cfg, shutdown_type);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, lock_flags);
|
|
wait_event(ioa_cfg->reset_wait_q, !ioa_cfg->in_reset_reload);
|
|
if (ipr_fast_reboot && system_state == SYSTEM_RESTART && ioa_cfg->sis64) {
|
|
ipr_free_irqs(ioa_cfg);
|
|
pci_disable_device(ioa_cfg->pdev);
|
|
}
|
|
}
|
|
|
|
static struct pci_device_id ipr_pci_table[] = {
|
|
{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5702, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_5703, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573D, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_MYLEX, PCI_DEVICE_ID_IBM_GEMSTONE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_573E, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571B, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572E, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571A, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CITRINE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575B, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572A, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572B, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT},
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_575C, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574E, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B3, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CC, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_OBSIDIAN_E,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B7, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT | IPR_USE_PCI_WARM_RESET },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_SNIPE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2780, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571E, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_571F, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_ADAPTEC2, PCI_DEVICE_ID_ADAPTEC2_SCAMP,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_572F, 0, 0,
|
|
IPR_USE_LONG_TRANSOP_TIMEOUT },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B5, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_574D, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B2, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C0, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C3, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROC_FPGA_E2,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C4, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B4, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57B1, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C6, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57C8, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57CE, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D5, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D6, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D7, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D8, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57D9, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57DA, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EB, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EC, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57ED, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EE, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57EF, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_57F0, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCA, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CD2, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_CROCODILE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_2CCD, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580A, 0, 0, 0 },
|
|
{ PCI_VENDOR_ID_IBM, PCI_DEVICE_ID_IBM_RATTLESNAKE,
|
|
PCI_VENDOR_ID_IBM, IPR_SUBS_DEV_ID_580B, 0, 0, 0 },
|
|
{ }
|
|
};
|
|
MODULE_DEVICE_TABLE(pci, ipr_pci_table);
|
|
|
|
static const struct pci_error_handlers ipr_err_handler = {
|
|
.error_detected = ipr_pci_error_detected,
|
|
.mmio_enabled = ipr_pci_mmio_enabled,
|
|
.slot_reset = ipr_pci_slot_reset,
|
|
};
|
|
|
|
static struct pci_driver ipr_driver = {
|
|
.name = IPR_NAME,
|
|
.id_table = ipr_pci_table,
|
|
.probe = ipr_probe,
|
|
.remove = ipr_remove,
|
|
.shutdown = ipr_shutdown,
|
|
.err_handler = &ipr_err_handler,
|
|
};
|
|
|
|
/**
|
|
* ipr_halt_done - Shutdown prepare completion
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void ipr_halt_done(struct ipr_cmnd *ipr_cmd)
|
|
{
|
|
list_add_tail(&ipr_cmd->queue, &ipr_cmd->hrrq->hrrq_free_q);
|
|
}
|
|
|
|
/**
|
|
* ipr_halt - Issue shutdown prepare to all adapters
|
|
*
|
|
* Return value:
|
|
* NOTIFY_OK on success / NOTIFY_DONE on failure
|
|
**/
|
|
static int ipr_halt(struct notifier_block *nb, ulong event, void *buf)
|
|
{
|
|
struct ipr_cmnd *ipr_cmd;
|
|
struct ipr_ioa_cfg *ioa_cfg;
|
|
unsigned long flags = 0, driver_lock_flags;
|
|
|
|
if (event != SYS_RESTART && event != SYS_HALT && event != SYS_POWER_OFF)
|
|
return NOTIFY_DONE;
|
|
|
|
spin_lock_irqsave(&ipr_driver_lock, driver_lock_flags);
|
|
|
|
list_for_each_entry(ioa_cfg, &ipr_ioa_head, queue) {
|
|
spin_lock_irqsave(ioa_cfg->host->host_lock, flags);
|
|
if (!ioa_cfg->hrrq[IPR_INIT_HRRQ].allow_cmds ||
|
|
(ipr_fast_reboot && event == SYS_RESTART && ioa_cfg->sis64)) {
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
continue;
|
|
}
|
|
|
|
ipr_cmd = ipr_get_free_ipr_cmnd(ioa_cfg);
|
|
ipr_cmd->ioarcb.res_handle = cpu_to_be32(IPR_IOA_RES_HANDLE);
|
|
ipr_cmd->ioarcb.cmd_pkt.request_type = IPR_RQTYPE_IOACMD;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[0] = IPR_IOA_SHUTDOWN;
|
|
ipr_cmd->ioarcb.cmd_pkt.cdb[1] = IPR_SHUTDOWN_PREPARE_FOR_NORMAL;
|
|
|
|
ipr_do_req(ipr_cmd, ipr_halt_done, ipr_timeout, IPR_DEVICE_RESET_TIMEOUT);
|
|
spin_unlock_irqrestore(ioa_cfg->host->host_lock, flags);
|
|
}
|
|
spin_unlock_irqrestore(&ipr_driver_lock, driver_lock_flags);
|
|
|
|
return NOTIFY_OK;
|
|
}
|
|
|
|
static struct notifier_block ipr_notifier = {
|
|
ipr_halt, NULL, 0
|
|
};
|
|
|
|
/**
|
|
* ipr_init - Module entry point
|
|
*
|
|
* Return value:
|
|
* 0 on success / negative value on failure
|
|
**/
|
|
static int __init ipr_init(void)
|
|
{
|
|
ipr_info("IBM Power RAID SCSI Device Driver version: %s %s\n",
|
|
IPR_DRIVER_VERSION, IPR_DRIVER_DATE);
|
|
|
|
register_reboot_notifier(&ipr_notifier);
|
|
return pci_register_driver(&ipr_driver);
|
|
}
|
|
|
|
/**
|
|
* ipr_exit - Module unload
|
|
*
|
|
* Module unload entry point.
|
|
*
|
|
* Return value:
|
|
* none
|
|
**/
|
|
static void __exit ipr_exit(void)
|
|
{
|
|
unregister_reboot_notifier(&ipr_notifier);
|
|
pci_unregister_driver(&ipr_driver);
|
|
}
|
|
|
|
module_init(ipr_init);
|
|
module_exit(ipr_exit);
|