Google Git
Sign in
android-kvm / linux / 477b4e80c57f787cf8f494ccb9be23a23642b2f2 / . / drivers / scsi / qla1280.c
blob: d0b4e063bfe1e4c0fbeb6524a2b84f24402a9a55 [file] [log] [blame]
// SPDX-License-Identifier: GPL-2.0-or-later
/******************************************************************************
* QLOGIC LINUX SOFTWARE
*
* QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver
* Copyright (C) 2000 Qlogic Corporation (www.qlogic.com)
* Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc.
* Copyright (C) 2003-2004 Christoph Hellwig
*
******************************************************************************/
#define QLA1280_VERSION "3.27.1"
/*****************************************************************************
Revision History:
Rev 3.27.1, February 8, 2010, Michael Reed
- Retain firmware image for error recovery.
Rev 3.27, February 10, 2009, Michael Reed
- General code cleanup.
- Improve error recovery.
Rev 3.26, January 16, 2006 Jes Sorensen
- Ditch all < 2.6 support
Rev 3.25.1, February 10, 2005 Christoph Hellwig
- use pci_map_single to map non-S/G requests
- remove qla1280_proc_info
Rev 3.25, September 28, 2004, Christoph Hellwig
- add support for ISP1020/1040
- don't include "scsi.h" anymore for 2.6.x
Rev 3.24.4 June 7, 2004 Christoph Hellwig
- restructure firmware loading, cleanup initialization code
- prepare support for ISP1020/1040 chips
Rev 3.24.3 January 19, 2004, Jes Sorensen
- Handle PCI DMA mask settings correctly
- Correct order of error handling in probe_one, free_irq should not
be called if request_irq failed
Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
- Big endian fixes (James)
- Remove bogus IOCB content on zero data transfer commands (Andrew)
Rev 3.24.1 January 5, 2004, Jes Sorensen
- Initialize completion queue to avoid OOPS on probe
- Handle interrupts during mailbox testing
Rev 3.24 November 17, 2003, Christoph Hellwig
- use struct list_head for completion queue
- avoid old Scsi_FOO typedefs
- cleanup 2.4 compat glue a bit
- use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
- make initialization for memory mapped vs port I/O more similar
- remove broken pci config space manipulation
- kill more cruft
- this is an almost perfect 2.6 scsi driver now! ;)
Rev 3.23.39 December 17, 2003, Jes Sorensen
- Delete completion queue from srb if mailbox command failed to
to avoid qla1280_done completeting qla1280_error_action's
obsolete context
- Reduce arguments for qla1280_done
Rev 3.23.38 October 18, 2003, Christoph Hellwig
- Convert to new-style hotplugable driver for 2.6
- Fix missing scsi_unregister/scsi_host_put on HBA removal
- Kill some more cruft
Rev 3.23.37 October 1, 2003, Jes Sorensen
- Make MMIO depend on CONFIG_X86_VISWS instead of yet another
random CONFIG option
- Clean up locking in probe path
Rev 3.23.36 October 1, 2003, Christoph Hellwig
- queuecommand only ever receives new commands - clear flags
- Reintegrate lost fixes from Linux 2.5
Rev 3.23.35 August 14, 2003, Jes Sorensen
- Build against 2.6
Rev 3.23.34 July 23, 2003, Jes Sorensen
- Remove pointless TRUE/FALSE macros
- Clean up vchan handling
Rev 3.23.33 July 3, 2003, Jes Sorensen
- Don't define register access macros before define determining MMIO.
This just happened to work out on ia64 but not elsewhere.
- Don't try and read from the card while it is in reset as
it won't respond and causes an MCA
Rev 3.23.32 June 23, 2003, Jes Sorensen
- Basic support for boot time arguments
Rev 3.23.31 June 8, 2003, Jes Sorensen
- Reduce boot time messages
Rev 3.23.30 June 6, 2003, Jes Sorensen
- Do not enable sync/wide/ppr before it has been determined
that the target device actually supports it
- Enable DMA arbitration for multi channel controllers
Rev 3.23.29 June 3, 2003, Jes Sorensen
- Port to 2.5.69
Rev 3.23.28 June 3, 2003, Jes Sorensen
- Eliminate duplicate marker commands on bus resets
- Handle outstanding commands appropriately on bus/device resets
Rev 3.23.27 May 28, 2003, Jes Sorensen
- Remove bogus input queue code, let the Linux SCSI layer do the work
- Clean up NVRAM handling, only read it once from the card
- Add a number of missing default nvram parameters
Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
- Use completion queue for mailbox commands instead of busy wait
Rev 3.23.25 Beta May 27, 2003, James Bottomley
- Migrate to use new error handling code
Rev 3.23.24 Beta May 21, 2003, James Bottomley
- Big endian support
- Cleanup data direction code
Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
- Switch to using MMIO instead of PIO
Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
- Fix PCI parity problem with 12160 during reset.
Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
- Use pci_map_page()/pci_unmap_page() instead of map_single version.
Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
- Remove < 2.4.x support
- Introduce HOST_LOCK to make the spin lock changes portable.
- Remove a bunch of idiotic and unnecessary typedef's
- Kill all leftovers of target-mode support which never worked anyway
Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
- Do qla1280_pci_config() before calling request_irq() and
request_region()
- Use pci_dma_hi32() to handle upper word of DMA addresses instead
of large shifts
- Hand correct arguments to free_irq() in case of failure
Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
- Run source through Lindent and clean up the output
Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
- Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
- Rely on mailbox commands generating interrupts - do not
run qla1280_isr() from ql1280_mailbox_command()
- Remove device_reg_t
- Integrate ql12160_set_target_parameters() with 1280 version
- Make qla1280_setup() non static
- Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
sent to the card - this command pauses the firmware!!!
Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
- Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
- Remove a pile of pointless and confusing (srb_t **) and
(scsi_lu_t *) typecasts
- Explicit mark that we do not use the new error handling (for now)
- Remove scsi_qla_host_t and use 'struct' instead
- Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
pci_64bit_slot flags which weren't used for anything anyway
- Grab host->host_lock while calling qla1280_isr() from abort()
- Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
do not need to save/restore flags in the interrupt handler
- Enable interrupts early (before any mailbox access) in preparation
for cleaning up the mailbox handling
Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
- Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
it with proper use of dprintk().
- Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
a debug level argument to determine if data is to be printed
- Add KERN_* info to printk()
Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
- Significant cosmetic cleanups
- Change debug code to use dprintk() and remove #if mess
Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
- More cosmetic cleanups, fix places treating return as function
- use cpu_relax() in qla1280_debounce_register()
Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
- Make it compile under 2.5.5
Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
- Do no typecast short * to long * in QL1280BoardTbl, this
broke miserably on big endian boxes
Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
- Remove pre 2.2 hack for checking for reentrance in interrupt handler
- Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
unsigned int to match the types from struct scsi_cmnd
Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
- Remove bogus timer_t typedef from qla1280.h
- Remove obsolete pre 2.2 PCI setup code, use proper #define's
for PCI_ values, call pci_set_master()
- Fix memleak of qla1280_buffer on module unload
- Only compile module parsing code #ifdef MODULE - should be
changed to use individual MODULE_PARM's later
- Remove dummy_buffer that was never modified nor printed
- ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
#ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
- Remove \r from print statements, this is Linux, not DOS
- Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
dummy macros
- Remove C++ compile hack in header file as Linux driver are not
supposed to be compiled as C++
- Kill MS_64BITS macro as it makes the code more readable
- Remove unnecessary flags.in_interrupts bit
Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
- Dont' check for set flags on q->q_flag one by one in qla1280_next()
- Check whether the interrupt was generated by the QLA1280 before
doing any processing
- qla1280_status_entry(): Only zero out part of sense_buffer that
is not being copied into
- Remove more superflouous typecasts
- qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
- Don't walk the entire list in qla1280_putq_t() just to directly
grab the pointer to the last element afterwards
Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
- Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
- Set dev->max_sectors to 1024
Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
- Provide compat macros for pci_enable_device(), pci_find_subsys()
and scsi_set_pci_device()
- Call scsi_set_pci_device() for all devices
- Reduce size of kernel version dependent device probe code
- Move duplicate probe/init code to separate function
- Handle error if qla1280_mem_alloc() fails
- Kill OFFSET() macro and use Linux's PCI definitions instead
- Kill private structure defining PCI config space (struct config_reg)
- Only allocate I/O port region if not in MMIO mode
- Remove duplicate (unused) sanity check of sife of srb_t
Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
- Change home-brew memset() implementations to use memset()
- Remove all references to COMTRACE() - accessing a PC's COM2 serial
port directly is not legal under Linux.
Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
- Remove pre 2.2 kernel support
- clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
- Fix MMIO access to use readl/writel instead of directly
dereferencing pointers
- Nuke MSDOS debugging code
- Change true/false data types to int from uint8_t
- Use int for counters instead of uint8_t etc.
- Clean up size & byte order conversion macro usage
Rev 3.23 Beta January 11, 2001 BN Qlogic
- Added check of device_id when handling non
QLA12160s during detect().
Rev 3.22 Beta January 5, 2001 BN Qlogic
- Changed queue_task() to schedule_task()
for kernels 2.4.0 and higher.
Note: 2.4.0-testxx kernels released prior to
the actual 2.4.0 kernel release on January 2001
will get compile/link errors with schedule_task().
Please update your kernel to released 2.4.0 level,
or comment lines in this file flagged with 3.22
to resolve compile/link error of schedule_task().
- Added -DCONFIG_SMP in addition to -D__SMP__
in Makefile for 2.4.0 builds of driver as module.
Rev 3.21 Beta January 4, 2001 BN Qlogic
- Changed criteria of 64/32 Bit mode of HBA
operation according to BITS_PER_LONG rather
than HBA's NVRAM setting of >4Gig memory bit;
so that the HBA auto-configures without the need
to setup each system individually.
Rev 3.20 Beta December 5, 2000 BN Qlogic
- Added priority handling to IA-64 onboard SCSI
ISP12160 chip for kernels greater than 2.3.18.
- Added irqrestore for qla1280_intr_handler.
- Enabled /proc/scsi/qla1280 interface.
- Clear /proc/scsi/qla1280 counters in detect().
Rev 3.19 Beta October 13, 2000 BN Qlogic
- Declare driver_template for new kernel
(2.4.0 and greater) scsi initialization scheme.
- Update /proc/scsi entry for 2.3.18 kernels and
above as qla1280
Rev 3.18 Beta October 10, 2000 BN Qlogic
- Changed scan order of adapters to map
the QLA12160 followed by the QLA1280.
Rev 3.17 Beta September 18, 2000 BN Qlogic
- Removed warnings for 32 bit 2.4.x compiles
- Corrected declared size for request and response
DMA addresses that are kept in each ha
Rev. 3.16 Beta August 25, 2000 BN Qlogic
- Corrected 64 bit addressing issue on IA-64
where the upper 32 bits were not properly
passed to the RISC engine.
Rev. 3.15 Beta August 22, 2000 BN Qlogic
- Modified qla1280_setup_chip to properly load
ISP firmware for greater that 4 Gig memory on IA-64
Rev. 3.14 Beta August 16, 2000 BN Qlogic
- Added setting of dma_mask to full 64 bit
if flags.enable_64bit_addressing is set in NVRAM
Rev. 3.13 Beta August 16, 2000 BN Qlogic
- Use new PCI DMA mapping APIs for 2.4.x kernel
Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
- Added check of pci_enable_device to detect() for 2.3.x
- Use pci_resource_start() instead of
pdev->resource[0].start in detect() for 2.3.x
- Updated driver version
Rev. 3.11 July 14, 2000 BN Qlogic
- Updated SCSI Firmware to following versions:
qla1x80: 8.13.08
qla1x160: 10.04.08
- Updated driver version to 3.11
Rev. 3.10 June 23, 2000 BN Qlogic
- Added filtering of AMI SubSys Vendor ID devices
Rev. 3.9
- DEBUG_QLA1280 undefined and new version BN Qlogic
Rev. 3.08b May 9, 2000 MD Dell
- Added logic to check against AMI subsystem vendor ID
Rev. 3.08 May 4, 2000 DG Qlogic
- Added logic to check for PCI subsystem ID.
Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
- Updated SCSI Firmware to following versions:
qla12160: 10.01.19
qla1280: 8.09.00
Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
- Internal revision; not released
Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
- Edit correction for virt_to_bus and PROC.
Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
- Merge changes from ia64 port.
Rev. 3.03 Mar 28, 2000 BN Qlogic
- Increase version to reflect new code drop with compile fix
of issue with inclusion of linux/spinlock for 2.3 kernels
Rev. 3.02 Mar 15, 2000 BN Qlogic
- Merge qla1280_proc_info from 2.10 code base
Rev. 3.01 Feb 10, 2000 BN Qlogic
- Corrected code to compile on a 2.2.x kernel.
Rev. 3.00 Jan 17, 2000 DG Qlogic
- Added 64-bit support.
Rev. 2.07 Nov 9, 1999 DG Qlogic
- Added new routine to set target parameters for ISP12160.
Rev. 2.06 Sept 10, 1999 DG Qlogic
- Added support for ISP12160 Ultra 3 chip.
Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
- Modified code to remove errors generated when compiling with
Cygnus IA64 Compiler.
- Changed conversion of pointers to unsigned longs instead of integers.
- Changed type of I/O port variables from uint32_t to unsigned long.
- Modified OFFSET macro to work with 64-bit as well as 32-bit.
- Changed sprintf and printk format specifiers for pointers to %p.
- Changed some int to long type casts where needed in sprintf & printk.
- Added l modifiers to sprintf and printk format specifiers for longs.
- Removed unused local variables.
Rev. 1.20 June 8, 1999 DG, Qlogic
Changes to support RedHat release 6.0 (kernel 2.2.5).
- Added SCSI exclusive access lock (io_request_lock) when accessing
the adapter.
- Added changes for the new LINUX interface template. Some new error
handling routines have been added to the template, but for now we
will use the old ones.
- Initial Beta Release.
*****************************************************************************/
#include <linux/module.h>
#include <linux/types.h>
#include <linux/string.h>
#include <linux/errno.h>
#include <linux/kernel.h>
#include <linux/ioport.h>
#include <linux/delay.h>
#include <linux/timer.h>
#include <linux/pci.h>
#include <linux/proc_fs.h>
#include <linux/stat.h>
#include <linux/pci_ids.h>
#include <linux/interrupt.h>
#include <linux/init.h>
#include <linux/dma-mapping.h>
#include <linux/firmware.h>
#include <asm/io.h>
#include <asm/irq.h>
#include <asm/byteorder.h>
#include <asm/processor.h>
#include <asm/types.h>
#include <scsi/scsi.h>
#include <scsi/scsi_cmnd.h>
#include <scsi/scsi_device.h>
#include <scsi/scsi_host.h>
#include <scsi/scsi_tcq.h>
/*
* Compile time Options:
* 0 - Disable and 1 - Enable
*/
#define DEBUG_QLA1280_INTR 0
#define DEBUG_PRINT_NVRAM 0
#define DEBUG_QLA1280 0
#define MEMORY_MAPPED_IO 1
#include "qla1280.h"
#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
#define QLA_64BIT_PTR 1
#endif
#define NVRAM_DELAY() udelay(500) /* 2 microseconds */
#define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
#define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
#define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
static void qla1280_remove_one(struct pci_dev *);
/*
* QLogic Driver Support Function Prototypes.
*/
static void qla1280_done(struct scsi_qla_host *);
static int qla1280_get_token(char *);
static int qla1280_setup(char *s) __init;
/*
* QLogic ISP1280 Hardware Support Function Prototypes.
*/
static int qla1280_load_firmware(struct scsi_qla_host *);
static int qla1280_init_rings(struct scsi_qla_host *);
static int qla1280_nvram_config(struct scsi_qla_host *);
static int qla1280_mailbox_command(struct scsi_qla_host *,
uint8_t, uint16_t *);
static int qla1280_bus_reset(struct scsi_qla_host *, int);
static int qla1280_device_reset(struct scsi_qla_host *, int, int);
static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
static int qla1280_abort_isp(struct scsi_qla_host *);
#ifdef QLA_64BIT_PTR
static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
#else
static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
#endif
static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
static void qla1280_poll(struct scsi_qla_host *);
static void qla1280_reset_adapter(struct scsi_qla_host *);
static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
static void qla1280_isp_cmd(struct scsi_qla_host *);
static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
static void qla1280_rst_aen(struct scsi_qla_host *);
static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
struct list_head *);
static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
struct list_head *);
static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
static request_t *qla1280_req_pkt(struct scsi_qla_host *);
static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
unsigned int);
static void qla1280_get_target_parameters(struct scsi_qla_host *,
struct scsi_device *);
static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
static struct qla_driver_setup driver_setup;
/*
* convert scsi data direction to request_t control flags
*/
static inline uint16_t
qla1280_data_direction(struct scsi_cmnd *cmnd)
{
switch(cmnd->sc_data_direction) {
case DMA_FROM_DEVICE:
return BIT_5;
case DMA_TO_DEVICE:
return BIT_6;
case DMA_BIDIRECTIONAL:
return BIT_5 | BIT_6;
/*
* We could BUG() on default here if one of the four cases aren't
* met, but then again if we receive something like that from the
* SCSI layer we have more serious problems. This shuts up GCC.
*/
case DMA_NONE:
default:
return 0;
}
}
#if DEBUG_QLA1280
static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
static void __qla1280_dump_buffer(char *, int);
#endif
/*
* insmod needs to find the variable and make it point to something
*/
#ifdef MODULE
static char *qla1280;
/* insmod qla1280 options=verbose" */
module_param(qla1280, charp, 0);
#else
__setup("qla1280=", qla1280_setup);
#endif
/*
* We use the scsi_pointer structure that's included with each scsi_command
* to overlay our struct srb over it. qla1280_init() checks that a srb is not
* bigger than a scsi_pointer.
*/
#define CMD_SP(Cmnd) &Cmnd->SCp
#define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
#define CMD_CDBP(Cmnd) Cmnd->cmnd
#define CMD_SNSP(Cmnd) Cmnd->sense_buffer
#define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
#define CMD_RESULT(Cmnd) Cmnd->result
#define CMD_HANDLE(Cmnd) Cmnd->host_scribble
#define CMD_HOST(Cmnd) Cmnd->device->host
#define SCSI_BUS_32(Cmnd) Cmnd->device->channel
#define SCSI_TCN_32(Cmnd) Cmnd->device->id
#define SCSI_LUN_32(Cmnd) Cmnd->device->lun
/*****************************************/
/* ISP Boards supported by this driver */
/*****************************************/
struct qla_boards {
char *name; /* Board ID String */
int numPorts; /* Number of SCSI ports */
int fw_index; /* index into qla1280_fw_tbl for firmware */
};
/* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
static struct pci_device_id qla1280_pci_tbl[] = {
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
{PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
{0,}
};
MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
static DEFINE_MUTEX(qla1280_firmware_mutex);
struct qla_fw {
char *fwname;
const struct firmware *fw;
};
#define QL_NUM_FW_IMAGES 3
static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
{"qlogic/1040.bin", NULL}, /* image 0 */
{"qlogic/1280.bin", NULL}, /* image 1 */
{"qlogic/12160.bin", NULL}, /* image 2 */
};
/* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
static struct qla_boards ql1280_board_tbl[] = {
{.name = "QLA12160", .numPorts = 2, .fw_index = 2},
{.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
{.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
{.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
{.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
{.name = "QLA10160", .numPorts = 1, .fw_index = 2},
{.name = " ", .numPorts = 0, .fw_index = -1},
};
static int qla1280_verbose = 1;
#if DEBUG_QLA1280
static int ql_debug_level = 1;
#define dprintk(level, format, a...) \
do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
#define qla1280_dump_buffer(level, buf, size) \
if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
#define qla1280_print_scsi_cmd(level, cmd) \
if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
#else
#define ql_debug_level 0
#define dprintk(level, format, a...) do{}while(0)
#define qla1280_dump_buffer(a, b, c) do{}while(0)
#define qla1280_print_scsi_cmd(a, b) do{}while(0)
#endif
#define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
#define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
#define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
#define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
static int qla1280_read_nvram(struct scsi_qla_host *ha)
{
uint16_t *wptr;
uint8_t chksum;
int cnt, i;
struct nvram *nv;
ENTER("qla1280_read_nvram");
if (driver_setup.no_nvram)
return 1;
printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
wptr = (uint16_t *)&ha->nvram;
nv = &ha->nvram;
chksum = 0;
for (cnt = 0; cnt < 3; cnt++) {
*wptr = qla1280_get_nvram_word(ha, cnt);
chksum += *wptr & 0xff;
chksum += (*wptr >> 8) & 0xff;
wptr++;
}
if (nv->id0 != 'I' || nv->id1 != 'S' ||
nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
dprintk(2, "Invalid nvram ID or version!\n");
chksum = 1;
} else {
for (; cnt < sizeof(struct nvram); cnt++) {
*wptr = qla1280_get_nvram_word(ha, cnt);
chksum += *wptr & 0xff;
chksum += (*wptr >> 8) & 0xff;
wptr++;
}
}
dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
" version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
nv->version);
if (chksum) {
if (!driver_setup.no_nvram)
printk(KERN_WARNING "scsi(%ld): Unable to identify or "
"validate NVRAM checksum, using default "
"settings\n", ha->host_no);
ha->nvram_valid = 0;
} else
ha->nvram_valid = 1;
/* The firmware interface is, um, interesting, in that the
* actual firmware image on the chip is little endian, thus,
* the process of taking that image to the CPU would end up
* little endian. However, the firmware interface requires it
* to be read a word (two bytes) at a time.
*
* The net result of this would be that the word (and
* doubleword) quantities in the firmware would be correct, but
* the bytes would be pairwise reversed. Since most of the
* firmware quantities are, in fact, bytes, we do an extra
* le16_to_cpu() in the firmware read routine.
*
* The upshot of all this is that the bytes in the firmware
* are in the correct places, but the 16 and 32 bit quantities
* are still in little endian format. We fix that up below by
* doing extra reverses on them */
nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
for(i = 0; i < MAX_BUSES; i++) {
nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
}
dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
LEAVE("qla1280_read_nvram");
return chksum;
}
/**************************************************************************
* qla1280_info
* Return a string describing the driver.
**************************************************************************/
static const char *
qla1280_info(struct Scsi_Host *host)
{
static char qla1280_scsi_name_buffer[125];
char *bp;
struct scsi_qla_host *ha;
struct qla_boards *bdp;
bp = &qla1280_scsi_name_buffer[0];
ha = (struct scsi_qla_host *)host->hostdata;
bdp = &ql1280_board_tbl[ha->devnum];
memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
sprintf (bp,
"QLogic %s PCI to SCSI Host Adapter\n"
" Firmware version: %2d.%02d.%02d, Driver version %s",
&bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
QLA1280_VERSION);
return bp;
}
/**************************************************************************
* qla1280_queuecommand
* Queue a command to the controller.
*
* Note:
* The mid-level driver tries to ensures that queuecommand never gets invoked
* concurrently with itself or the interrupt handler (although the
* interrupt handler may call this routine as part of request-completion
* handling). Unfortunately, it sometimes calls the scheduler in interrupt
* context which is a big NO! NO!.
**************************************************************************/
static int
qla1280_queuecommand_lck(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
{
struct Scsi_Host *host = cmd->device->host;
struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
struct srb *sp = (struct srb *)CMD_SP(cmd);
int status;
cmd->scsi_done = fn;
sp->cmd = cmd;
sp->flags = 0;
sp->wait = NULL;
CMD_HANDLE(cmd) = (unsigned char *)NULL;
qla1280_print_scsi_cmd(5, cmd);
#ifdef QLA_64BIT_PTR
/*
* Using 64 bit commands if the PCI bridge doesn't support it is a
* bit wasteful, however this should really only happen if one's
* PCI controller is completely broken, like the BCM1250. For
* sane hardware this is not an issue.
*/
status = qla1280_64bit_start_scsi(ha, sp);
#else
status = qla1280_32bit_start_scsi(ha, sp);
#endif
return status;
}
static DEF_SCSI_QCMD(qla1280_queuecommand)
enum action {
ABORT_COMMAND,
DEVICE_RESET,
BUS_RESET,
ADAPTER_RESET,
};
static void qla1280_mailbox_timeout(struct timer_list *t)
{
struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
struct device_reg __iomem *reg;
reg = ha->iobase;
ha->mailbox_out[0] = RD_REG_WORD(&reg->mailbox0);
printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
"ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
RD_REG_WORD(&reg->ictrl), RD_REG_WORD(&reg->istatus));
complete(ha->mailbox_wait);
}
static int
_qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
struct completion *wait)
{
int status = FAILED;
struct scsi_cmnd *cmd = sp->cmd;
spin_unlock_irq(ha->host->host_lock);
wait_for_completion_timeout(wait, 4*HZ);
spin_lock_irq(ha->host->host_lock);
sp->wait = NULL;
if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
status = SUCCESS;
(*cmd->scsi_done)(cmd);
}
return status;
}
static int
qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
{
DECLARE_COMPLETION_ONSTACK(wait);
sp->wait = &wait;
return _qla1280_wait_for_single_command(ha, sp, &wait);
}
static int
qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
{
int cnt;
int status;
struct srb *sp;
struct scsi_cmnd *cmd;
status = SUCCESS;
/*
* Wait for all commands with the designated bus/target
* to be completed by the firmware
*/
for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
continue;
if (target >= 0 && SCSI_TCN_32(cmd) != target)
continue;
status = qla1280_wait_for_single_command(ha, sp);
if (status == FAILED)
break;
}
}
return status;
}
/**************************************************************************
* qla1280_error_action
* The function will attempt to perform a specified error action and
* wait for the results (or time out).
*
* Input:
* cmd = Linux SCSI command packet of the command that cause the
* bus reset.
* action = error action to take (see action_t)
*
* Returns:
* SUCCESS or FAILED
*
**************************************************************************/
static int
qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
{
struct scsi_qla_host *ha;
int bus, target, lun;
struct srb *sp;
int i, found;
int result=FAILED;
int wait_for_bus=-1;
int wait_for_target = -1;
DECLARE_COMPLETION_ONSTACK(wait);
ENTER("qla1280_error_action");
ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
sp = (struct srb *)CMD_SP(cmd);
bus = SCSI_BUS_32(cmd);
target = SCSI_TCN_32(cmd);
lun = SCSI_LUN_32(cmd);
dprintk(4, "error_action %i, istatus 0x%04x\n", action,
RD_REG_WORD(&ha->iobase->istatus));
dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
RD_REG_WORD(&ha->iobase->host_cmd),
RD_REG_WORD(&ha->iobase->ictrl), jiffies);
if (qla1280_verbose)
printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
"Handle=0x%p, action=0x%x\n",
ha->host_no, cmd, CMD_HANDLE(cmd), action);
/*
* Check to see if we have the command in the outstanding_cmds[]
* array. If not then it must have completed before this error
* action was initiated. If the error_action isn't ABORT_COMMAND
* then the driver must proceed with the requested action.
*/
found = -1;
for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
if (sp == ha->outstanding_cmds[i]) {
found = i;
sp->wait = &wait; /* we'll wait for it to complete */
break;
}
}
if (found < 0) { /* driver doesn't have command */
result = SUCCESS;
if (qla1280_verbose) {
printk(KERN_INFO
"scsi(%ld:%d:%d:%d): specified command has "
"already completed.\n", ha->host_no, bus,
target, lun);
}
}
switch (action) {
case ABORT_COMMAND:
dprintk(1, "qla1280: RISC aborting command\n");
/*
* The abort might fail due to race when the host_lock
* is released to issue the abort. As such, we
* don't bother to check the return status.
*/
if (found >= 0)
qla1280_abort_command(ha, sp, found);
break;
case DEVICE_RESET:
if (qla1280_verbose)
printk(KERN_INFO
"scsi(%ld:%d:%d:%d): Queueing device reset "
"command.\n", ha->host_no, bus, target, lun);
if (qla1280_device_reset(ha, bus, target) == 0) {
/* issued device reset, set wait conditions */
wait_for_bus = bus;
wait_for_target = target;
}
break;
case BUS_RESET:
if (qla1280_verbose)
printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
"reset.\n", ha->host_no, bus);
if (qla1280_bus_reset(ha, bus) == 0) {
/* issued bus reset, set wait conditions */
wait_for_bus = bus;
}
break;
case ADAPTER_RESET:
default:
if (qla1280_verbose) {
printk(KERN_INFO
"scsi(%ld): Issued ADAPTER RESET\n",
ha->host_no);
printk(KERN_INFO "scsi(%ld): I/O processing will "
"continue automatically\n", ha->host_no);
}
ha->flags.reset_active = 1;
if (qla1280_abort_isp(ha) != 0) { /* it's dead */
result = FAILED;
}
ha->flags.reset_active = 0;
}
/*
* At this point, the host_lock has been released and retaken
* by the issuance of the mailbox command.
* Wait for the command passed in by the mid-layer if it
* was found by the driver. It might have been returned
* between eh recovery steps, hence the check of the "found"
* variable.
*/
if (found >= 0)
result = _qla1280_wait_for_single_command(ha, sp, &wait);
if (action == ABORT_COMMAND && result != SUCCESS) {
printk(KERN_WARNING
"scsi(%li:%i:%i:%i): "
"Unable to abort command!\n",
ha->host_no, bus, target, lun);
}
/*
* If the command passed in by the mid-layer has been
* returned by the board, then wait for any additional
* commands which are supposed to complete based upon
* the error action.
*
* All commands are unconditionally returned during a
* call to qla1280_abort_isp(), ADAPTER_RESET. No need
* to wait for them.
*/
if (result == SUCCESS && wait_for_bus >= 0) {
result = qla1280_wait_for_pending_commands(ha,
wait_for_bus, wait_for_target);
}
dprintk(1, "RESET returning %d\n", result);
LEAVE("qla1280_error_action");
return result;
}
/**************************************************************************
* qla1280_abort
* Abort the specified SCSI command(s).
**************************************************************************/
static int
qla1280_eh_abort(struct scsi_cmnd * cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, ABORT_COMMAND);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/**************************************************************************
* qla1280_device_reset
* Reset the specified SCSI device
**************************************************************************/
static int
qla1280_eh_device_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, DEVICE_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/**************************************************************************
* qla1280_bus_reset
* Reset the specified bus.
**************************************************************************/
static int
qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, BUS_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
/**************************************************************************
* qla1280_adapter_reset
* Reset the specified adapter (both channels)
**************************************************************************/
static int
qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
{
int rc;
spin_lock_irq(cmd->device->host->host_lock);
rc = qla1280_error_action(cmd, ADAPTER_RESET);
spin_unlock_irq(cmd->device->host->host_lock);
return rc;
}
static int
qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
sector_t capacity, int geom[])
{
int heads, sectors, cylinders;
heads = 64;
sectors = 32;
cylinders = (unsigned long)capacity / (heads * sectors);
if (cylinders > 1024) {
heads = 255;
sectors = 63;
cylinders = (unsigned long)capacity / (heads * sectors);
/* if (cylinders > 1023)
cylinders = 1023; */
}
geom[0] = heads;
geom[1] = sectors;
geom[2] = cylinders;
return 0;
}
/* disable risc and host interrupts */
static inline void
qla1280_disable_intrs(struct scsi_qla_host *ha)
{
WRT_REG_WORD(&ha->iobase->ictrl, 0);
RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
}
/* enable risc and host interrupts */
static inline void
qla1280_enable_intrs(struct scsi_qla_host *ha)
{
WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
}
/**************************************************************************
* qla1280_intr_handler
* Handles the H/W interrupt
**************************************************************************/
static irqreturn_t
qla1280_intr_handler(int irq, void *dev_id)
{
struct scsi_qla_host *ha;
struct device_reg __iomem *reg;
u16 data;
int handled = 0;
ENTER_INTR ("qla1280_intr_handler");
ha = (struct scsi_qla_host *)dev_id;
spin_lock(ha->host->host_lock);
ha->isr_count++;
reg = ha->iobase;
qla1280_disable_intrs(ha);
data = qla1280_debounce_register(&reg->istatus);
/* Check for pending interrupts. */
if (data & RISC_INT) {
qla1280_isr(ha, &ha->done_q);
handled = 1;
}
if (!list_empty(&ha->done_q))
qla1280_done(ha);
spin_unlock(ha->host->host_lock);
qla1280_enable_intrs(ha);
LEAVE_INTR("qla1280_intr_handler");
return IRQ_RETVAL(handled);
}
static int
qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
{
uint8_t mr;
uint16_t mb[MAILBOX_REGISTER_COUNT];
struct nvram *nv;
int status, lun;
nv = &ha->nvram;
mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
/* Set Target Parameters. */
mb[0] = MBC_SET_TARGET_PARAMETERS;
mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
if (IS_ISP1x160(ha)) {
mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
mr |= BIT_6;
} else {
mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
}
mb[3] |= nv->bus[bus].target[target].sync_period;
status = qla1280_mailbox_command(ha, mr, mb);
/* Set Device Queue Parameters. */
for (lun = 0; lun < MAX_LUNS; lun++) {
mb[0] = MBC_SET_DEVICE_QUEUE;
mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
mb[1] |= lun;
mb[2] = nv->bus[bus].max_queue_depth;
mb[3] = nv->bus[bus].target[target].execution_throttle;
status |= qla1280_mailbox_command(ha, 0x0f, mb);
}
if (status)
printk(KERN_WARNING "scsi(%ld:%i:%i): "
"qla1280_set_target_parameters() failed\n",
ha->host_no, bus, target);
return status;
}
/**************************************************************************
* qla1280_slave_configure
*
* Description:
* Determines the queue depth for a given device. There are two ways
* a queue depth can be obtained for a tagged queueing device. One
* way is the default queue depth which is determined by whether
* If it is defined, then it is used
* as the default queue depth. Otherwise, we use either 4 or 8 as the
* default queue depth (dependent on the number of hardware SCBs).
**************************************************************************/
static int
qla1280_slave_configure(struct scsi_device *device)
{
struct scsi_qla_host *ha;
int default_depth = 3;
int bus = device->channel;
int target = device->id;
int status = 0;
struct nvram *nv;
unsigned long flags;
ha = (struct scsi_qla_host *)device->host->hostdata;
nv = &ha->nvram;
if (qla1280_check_for_dead_scsi_bus(ha, bus))
return 1;
if (device->tagged_supported &&
(ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
} else {
scsi_change_queue_depth(device, default_depth);
}
nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
if (driver_setup.no_sync ||
(driver_setup.sync_mask &&
(~driver_setup.sync_mask & (1 << target))))
nv->bus[bus].target[target].parameter.enable_sync = 0;
if (driver_setup.no_wide ||
(driver_setup.wide_mask &&
(~driver_setup.wide_mask & (1 << target))))
nv->bus[bus].target[target].parameter.enable_wide = 0;
if (IS_ISP1x160(ha)) {
if (driver_setup.no_ppr ||
(driver_setup.ppr_mask &&
(~driver_setup.ppr_mask & (1 << target))))
nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
}
spin_lock_irqsave(ha->host->host_lock, flags);
if (nv->bus[bus].target[target].parameter.enable_sync)
status = qla1280_set_target_parameters(ha, bus, target);
qla1280_get_target_parameters(ha, device);
spin_unlock_irqrestore(ha->host->host_lock, flags);
return status;
}
/*
* qla1280_done
* Process completed commands.
*
* Input:
* ha = adapter block pointer.
*/
static void
qla1280_done(struct scsi_qla_host *ha)
{
struct srb *sp;
struct list_head *done_q;
int bus, target;
struct scsi_cmnd *cmd;
ENTER("qla1280_done");
done_q = &ha->done_q;
while (!list_empty(done_q)) {
sp = list_entry(done_q->next, struct srb, list);
list_del(&sp->list);
cmd = sp->cmd;
bus = SCSI_BUS_32(cmd);
target = SCSI_TCN_32(cmd);
switch ((CMD_RESULT(cmd) >> 16)) {
case DID_RESET:
/* Issue marker command. */
if (!ha->flags.abort_isp_active)
qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
break;
case DID_ABORT:
sp->flags &= ~SRB_ABORT_PENDING;
sp->flags |= SRB_ABORTED;
break;
default:
break;
}
/* Release memory used for this I/O */
scsi_dma_unmap(cmd);
/* Call the mid-level driver interrupt handler */
ha->actthreads--;
if (sp->wait == NULL)
(*(cmd)->scsi_done)(cmd);
else
complete(sp->wait);
}
LEAVE("qla1280_done");
}
/*
* Translates a ISP error to a Linux SCSI error
*/
static int
qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
{
int host_status = DID_ERROR;
uint16_t comp_status = le16_to_cpu(sts->comp_status);
uint16_t state_flags = le16_to_cpu(sts->state_flags);
uint32_t residual_length = le32_to_cpu(sts->residual_length);
uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
#if DEBUG_QLA1280_INTR
static char *reason[] = {
"DID_OK",
"DID_NO_CONNECT",
"DID_BUS_BUSY",
"DID_TIME_OUT",
"DID_BAD_TARGET",
"DID_ABORT",
"DID_PARITY",
"DID_ERROR",
"DID_RESET",
"DID_BAD_INTR"
};
#endif /* DEBUG_QLA1280_INTR */
ENTER("qla1280_return_status");
#if DEBUG_QLA1280_INTR
/*
dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
comp_status);
*/
#endif
switch (comp_status) {
case CS_COMPLETE:
host_status = DID_OK;
break;
case CS_INCOMPLETE:
if (!(state_flags & SF_GOT_BUS))
host_status = DID_NO_CONNECT;
else if (!(state_flags & SF_GOT_TARGET))
host_status = DID_BAD_TARGET;
else if (!(state_flags & SF_SENT_CDB))
host_status = DID_ERROR;
else if (!(state_flags & SF_TRANSFERRED_DATA))
host_status = DID_ERROR;
else if (!(state_flags & SF_GOT_STATUS))
host_status = DID_ERROR;
else if (!(state_flags & SF_GOT_SENSE))
host_status = DID_ERROR;
break;
case CS_RESET:
host_status = DID_RESET;
break;
case CS_ABORTED:
host_status = DID_ABORT;
break;
case CS_TIMEOUT:
host_status = DID_TIME_OUT;
break;
case CS_DATA_OVERRUN:
dprintk(2, "Data overrun 0x%x\n", residual_length);
dprintk(2, "qla1280_return_status: response packet data\n");
qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
host_status = DID_ERROR;
break;
case CS_DATA_UNDERRUN:
if ((scsi_bufflen(cp) - residual_length) <
cp->underflow) {
printk(KERN_WARNING
"scsi: Underflow detected - retrying "
"command.\n");
host_status = DID_ERROR;
} else {
scsi_set_resid(cp, residual_length);
host_status = DID_OK;
}
break;
default:
host_status = DID_ERROR;
break;
}
#if DEBUG_QLA1280_INTR
dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
reason[host_status], scsi_status);
#endif
LEAVE("qla1280_return_status");
return (scsi_status & 0xff) | (host_status << 16);
}
/****************************************************************************/
/* QLogic ISP1280 Hardware Support Functions. */
/****************************************************************************/
/*
* qla1280_initialize_adapter
* Initialize board.
*
* Input:
* ha = adapter block pointer.
*
* Returns:
* 0 = success
*/
static int
qla1280_initialize_adapter(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg;
int status;
int bus;
unsigned long flags;
ENTER("qla1280_initialize_adapter");
/* Clear adapter flags. */
ha->flags.online = 0;
ha->flags.disable_host_adapter = 0;
ha->flags.reset_active = 0;
ha->flags.abort_isp_active = 0;
/* TODO: implement support for the 1040 nvram format */
if (IS_ISP1040(ha))
driver_setup.no_nvram = 1;
dprintk(1, "Configure PCI space for adapter...\n");
reg = ha->iobase;
/* Insure mailbox registers are free. */
WRT_REG_WORD(&reg->semaphore, 0);
WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
RD_REG_WORD(&reg->host_cmd);
if (qla1280_read_nvram(ha)) {
dprintk(2, "qla1280_initialize_adapter: failed to read "
"NVRAM\n");
}
/*
* It's necessary to grab the spin here as qla1280_mailbox_command
* needs to be able to drop the lock unconditionally to wait
* for completion.
*/
spin_lock_irqsave(ha->host->host_lock, flags);
status = qla1280_load_firmware(ha);
if (status) {
printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
ha->host_no);
goto out;
}
/* Setup adapter based on NVRAM parameters. */
dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
qla1280_nvram_config(ha);
if (ha->flags.disable_host_adapter) {
status = 1;
goto out;
}
status = qla1280_init_rings(ha);
if (status)
goto out;
/* Issue SCSI reset, if we can't reset twice then bus is dead */
for (bus = 0; bus < ha->ports; bus++) {
if (!ha->bus_settings[bus].disable_scsi_reset &&
qla1280_bus_reset(ha, bus) &&
qla1280_bus_reset(ha, bus))
ha->bus_settings[bus].scsi_bus_dead = 1;
}
ha->flags.online = 1;
out:
spin_unlock_irqrestore(ha->host->host_lock, flags);
if (status)
dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
LEAVE("qla1280_initialize_adapter");
return status;
}
/*
* qla1280_request_firmware
* Acquire firmware for chip. Retain in memory
* for error recovery.
*
* Input:
* ha = adapter block pointer.
*
* Returns:
* Pointer to firmware image or an error code
* cast to pointer via ERR_PTR().
*/
static const struct firmware *
qla1280_request_firmware(struct scsi_qla_host *ha)
{
const struct firmware *fw;
int err;
int index;
char *fwname;
spin_unlock_irq(ha->host->host_lock);
mutex_lock(&qla1280_firmware_mutex);
index = ql1280_board_tbl[ha->devnum].fw_index;
fw = qla1280_fw_tbl[index].fw;
if (fw)
goto out;
fwname = qla1280_fw_tbl[index].fwname;
err = request_firmware(&fw, fwname, &ha->pdev->dev);
if (err) {
printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
fwname, err);
fw = ERR_PTR(err);
goto unlock;
}
if ((fw->size % 2) || (fw->size < 6)) {
printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
fw->size, fwname);
release_firmware(fw);
fw = ERR_PTR(-EINVAL);
goto unlock;
}
qla1280_fw_tbl[index].fw = fw;
out:
ha->fwver1 = fw->data[0];
ha->fwver2 = fw->data[1];
ha->fwver3 = fw->data[2];
unlock:
mutex_unlock(&qla1280_firmware_mutex);
spin_lock_irq(ha->host->host_lock);
return fw;
}
/*
* Chip diagnostics
* Test chip for proper operation.
*
* Input:
* ha = adapter block pointer.
*
* Returns:
* 0 = success.
*/
static int
qla1280_chip_diag(struct scsi_qla_host *ha)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
struct device_reg __iomem *reg = ha->iobase;
int status = 0;
int cnt;
uint16_t data;
dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", &reg->id_l);
dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
/* Soft reset chip and wait for it to finish. */
WRT_REG_WORD(&reg->ictrl, ISP_RESET);
/*
* We can't do a traditional PCI write flush here by reading
* back the register. The card will not respond once the reset
* is in action and we end up with a machine check exception
* instead. Nothing to do but wait and hope for the best.
* A portable pci_write_flush(pdev) call would be very useful here.
*/
udelay(20);
data = qla1280_debounce_register(&reg->ictrl);
/*
* Yet another QLogic gem ;-(
*/
for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
udelay(5);
data = RD_REG_WORD(&reg->ictrl);
}
if (!cnt)
goto fail;
/* Reset register cleared by chip reset. */
dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
WRT_REG_WORD(&reg->cfg_1, 0);
/* Reset RISC and disable BIOS which
allows RISC to execute out of RAM. */
WRT_REG_WORD(&reg->host_cmd, HC_RESET_RISC |
HC_RELEASE_RISC | HC_DISABLE_BIOS);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
data = qla1280_debounce_register(&reg->mailbox0);
/*
* I *LOVE* this code!
*/
for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
udelay(5);
data = RD_REG_WORD(&reg->mailbox0);
}
if (!cnt)
goto fail;
/* Check product ID of chip */
dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
if (RD_REG_WORD(&reg->mailbox1) != PROD_ID_1 ||
(RD_REG_WORD(&reg->mailbox2) != PROD_ID_2 &&
RD_REG_WORD(&reg->mailbox2) != PROD_ID_2a) ||
RD_REG_WORD(&reg->mailbox3) != PROD_ID_3 ||
RD_REG_WORD(&reg->mailbox4) != PROD_ID_4) {
printk(KERN_INFO "qla1280: Wrong product ID = "
"0x%x,0x%x,0x%x,0x%x\n",
RD_REG_WORD(&reg->mailbox1),
RD_REG_WORD(&reg->mailbox2),
RD_REG_WORD(&reg->mailbox3),
RD_REG_WORD(&reg->mailbox4));
goto fail;
}
/*
* Enable ints early!!!
*/
qla1280_enable_intrs(ha);
dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
/* Wrap Incoming Mailboxes Test. */
mb[0] = MBC_MAILBOX_REGISTER_TEST;
mb[1] = 0xAAAA;
mb[2] = 0x5555;
mb[3] = 0xAA55;
mb[4] = 0x55AA;
mb[5] = 0xA5A5;
mb[6] = 0x5A5A;
mb[7] = 0x2525;
status = qla1280_mailbox_command(ha, 0xff, mb);
if (status)
goto fail;
if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
mb[7] != 0x2525) {
printk(KERN_INFO "qla1280: Failed mbox check\n");
goto fail;
}
dprintk(3, "qla1280_chip_diag: exiting normally\n");
return 0;
fail:
dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
return status;
}
static int
qla1280_load_firmware_pio(struct scsi_qla_host *ha)
{
/* enter with host_lock acquired */
const struct firmware *fw;
const __le16 *fw_data;
uint16_t risc_address, risc_code_size;
uint16_t mb[MAILBOX_REGISTER_COUNT], i;
int err = 0;
fw = qla1280_request_firmware(ha);
if (IS_ERR(fw))
return PTR_ERR(fw);
fw_data = (const __le16 *)&fw->data[0];
ha->fwstart = __le16_to_cpu(fw_data[2]);
/* Load RISC code. */
risc_address = ha->fwstart;
fw_data = (const __le16 *)&fw->data[6];
risc_code_size = (fw->size - 6) / 2;
for (i = 0; i < risc_code_size; i++) {
mb[0] = MBC_WRITE_RAM_WORD;
mb[1] = risc_address + i;
mb[2] = __le16_to_cpu(fw_data[i]);
err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
if (err) {
printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
ha->host_no);
break;
}
}
return err;
}
#ifdef QLA_64BIT_PTR
#define LOAD_CMD MBC_LOAD_RAM_A64_ROM
#define DUMP_CMD MBC_DUMP_RAM_A64_ROM
#define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
#else
#define LOAD_CMD MBC_LOAD_RAM
#define DUMP_CMD MBC_DUMP_RAM
#define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
#endif
#define DUMP_IT_BACK 0 /* for debug of RISC loading */
static int
qla1280_load_firmware_dma(struct scsi_qla_host *ha)
{
/* enter with host_lock acquired */
const struct firmware *fw;
const __le16 *fw_data;
uint16_t risc_address, risc_code_size;
uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
int err = 0, num, i;
#if DUMP_IT_BACK
uint8_t *sp, *tbuf;
dma_addr_t p_tbuf;
tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
if (!tbuf)
return -ENOMEM;
#endif
fw = qla1280_request_firmware(ha);
if (IS_ERR(fw))
return PTR_ERR(fw);
fw_data = (const __le16 *)&fw->data[0];
ha->fwstart = __le16_to_cpu(fw_data[2]);
/* Load RISC code. */
risc_address = ha->fwstart;
fw_data = (const __le16 *)&fw->data[6];
risc_code_size = (fw->size - 6) / 2;
dprintk(1, "%s: DMA RISC code (%i) words\n",
__func__, risc_code_size);
num = 0;
while (risc_code_size > 0) {
int warn __attribute__((unused)) = 0;
cnt = 2000 >> 1;
if (cnt > risc_code_size)
cnt = risc_code_size;
dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
"%d,%d(0x%x)\n",
fw_data, cnt, num, risc_address);
for(i = 0; i < cnt; i++)
((__le16 *)ha->request_ring)[i] = fw_data[i];
mb[0] = LOAD_CMD;
mb[1] = risc_address;
mb[4] = cnt;
mb[3] = ha->request_dma & 0xffff;
mb[2] = (ha->request_dma >> 16) & 0xffff;
mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
mb[6] = upper_32_bits(ha->request_dma) >> 16;
dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
__func__, mb[0],
(void *)(long)ha->request_dma,
mb[6], mb[7], mb[2], mb[3]);
err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
if (err) {
printk(KERN_ERR "scsi(%li): Failed to load partial "
"segment of f\n", ha->host_no);
goto out;
}
#if DUMP_IT_BACK
mb[0] = DUMP_CMD;
mb[1] = risc_address;
mb[4] = cnt;
mb[3] = p_tbuf & 0xffff;
mb[2] = (p_tbuf >> 16) & 0xffff;
mb[7] = upper_32_bits(p_tbuf) & 0xffff;
mb[6] = upper_32_bits(p_tbuf) >> 16;
err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
if (err) {
printk(KERN_ERR
"Failed to dump partial segment of f/w\n");
goto out;
}
sp = (uint8_t *)ha->request_ring;
for (i = 0; i < (cnt << 1); i++) {
if (tbuf[i] != sp[i] && warn++ < 10) {
printk(KERN_ERR "%s: FW compare error @ "
"byte(0x%x) loop#=%x\n",
__func__, i, num);
printk(KERN_ERR "%s: FWbyte=%x "
"FWfromChip=%x\n",
__func__, sp[i], tbuf[i]);
/*break; */
}
}
#endif
risc_address += cnt;
risc_code_size = risc_code_size - cnt;
fw_data = fw_data + cnt;
num++;
}
out:
#if DUMP_IT_BACK
dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
#endif
return err;
}
static int
qla1280_start_firmware(struct scsi_qla_host *ha)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
int err;
dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
__func__);
/* Verify checksum of loaded RISC code. */
mb[0] = MBC_VERIFY_CHECKSUM;
/* mb[1] = ql12_risc_code_addr01; */
mb[1] = ha->fwstart;
err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
if (err) {
printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
return err;
}
/* Start firmware execution. */
dprintk(1, "%s: start firmware running.\n", __func__);
mb[0] = MBC_EXECUTE_FIRMWARE;
mb[1] = ha->fwstart;
err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
if (err) {
printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
ha->host_no);
}
return err;
}
static int
qla1280_load_firmware(struct scsi_qla_host *ha)
{
/* enter with host_lock taken */
int err;
err = qla1280_chip_diag(ha);
if (err)
goto out;
if (IS_ISP1040(ha))
err = qla1280_load_firmware_pio(ha);
else
err = qla1280_load_firmware_dma(ha);
if (err)
goto out;
err = qla1280_start_firmware(ha);
out:
return err;
}
/*
* Initialize rings
*
* Input:
* ha = adapter block pointer.
* ha->request_ring = request ring virtual address
* ha->response_ring = response ring virtual address
* ha->request_dma = request ring physical address
* ha->response_dma = response ring physical address
*
* Returns:
* 0 = success.
*/
static int
qla1280_init_rings(struct scsi_qla_host *ha)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
int status = 0;
ENTER("qla1280_init_rings");
/* Clear outstanding commands array. */
memset(ha->outstanding_cmds, 0,
sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
/* Initialize request queue. */
ha->request_ring_ptr = ha->request_ring;
ha->req_ring_index = 0;
ha->req_q_cnt = REQUEST_ENTRY_CNT;
/* mb[0] = MBC_INIT_REQUEST_QUEUE; */
mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
mb[1] = REQUEST_ENTRY_CNT;
mb[3] = ha->request_dma & 0xffff;
mb[2] = (ha->request_dma >> 16) & 0xffff;
mb[4] = 0;
mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
mb[6] = upper_32_bits(ha->request_dma) >> 16;
if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
BIT_3 | BIT_2 | BIT_1 | BIT_0,
&mb[0]))) {
/* Initialize response queue. */
ha->response_ring_ptr = ha->response_ring;
ha->rsp_ring_index = 0;
/* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
mb[1] = RESPONSE_ENTRY_CNT;
mb[3] = ha->response_dma & 0xffff;
mb[2] = (ha->response_dma >> 16) & 0xffff;
mb[5] = 0;
mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
mb[6] = upper_32_bits(ha->response_dma) >> 16;
status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
BIT_3 | BIT_2 | BIT_1 | BIT_0,
&mb[0]);
}
if (status)
dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
LEAVE("qla1280_init_rings");
return status;
}
static void
qla1280_print_settings(struct nvram *nv)
{
dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
nv->bus[0].config_1.initiator_id);
dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
nv->bus[1].config_1.initiator_id);
dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
nv->bus[0].bus_reset_delay);
dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
nv->bus[1].bus_reset_delay);
dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
dprintk(1, "qla1280 : async data setup time[0]=%d\n",
nv->bus[0].config_2.async_data_setup_time);
dprintk(1, "qla1280 : async data setup time[1]=%d\n",
nv->bus[1].config_2.async_data_setup_time);
dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
nv->bus[0].config_2.req_ack_active_negation);
dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
nv->bus[1].config_2.req_ack_active_negation);
dprintk(1, "qla1280 : data line active negation[0]=%d\n",
nv->bus[0].config_2.data_line_active_negation);
dprintk(1, "qla1280 : data line active negation[1]=%d\n",
nv->bus[1].config_2.data_line_active_negation);
dprintk(1, "qla1280 : disable loading risc code=%d\n",
nv->cntr_flags_1.disable_loading_risc_code);
dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
nv->cntr_flags_1.enable_64bit_addressing);
dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
nv->bus[0].selection_timeout);
dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
nv->bus[1].selection_timeout);
dprintk(1, "qla1280 : max queue depth[0]=%d\n",
nv->bus[0].max_queue_depth);
dprintk(1, "qla1280 : max queue depth[1]=%d\n",
nv->bus[1].max_queue_depth);
}
static void
qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
{
struct nvram *nv = &ha->nvram;
nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
nv->bus[bus].target[target].parameter.auto_request_sense = 1;
nv->bus[bus].target[target].parameter.tag_queuing = 1;
nv->bus[bus].target[target].parameter.enable_sync = 1;
#if 1 /* Some SCSI Processors do not seem to like this */
nv->bus[bus].target[target].parameter.enable_wide = 1;
#endif
nv->bus[bus].target[target].execution_throttle =
nv->bus[bus].max_queue_depth - 1;
nv->bus[bus].target[target].parameter.parity_checking = 1;
nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
if (IS_ISP1x160(ha)) {
nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
nv->bus[bus].target[target].sync_period = 9;
nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
} else {
nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
nv->bus[bus].target[target].sync_period = 10;
}
}
static void
qla1280_set_defaults(struct scsi_qla_host *ha)
{
struct nvram *nv = &ha->nvram;
int bus, target;
dprintk(1, "Using defaults for NVRAM: \n");
memset(nv, 0, sizeof(struct nvram));
/* nv->cntr_flags_1.disable_loading_risc_code = 1; */
nv->firmware_feature.f.enable_fast_posting = 1;
nv->firmware_feature.f.disable_synchronous_backoff = 1;
nv->termination.scsi_bus_0_control = 3;
nv->termination.scsi_bus_1_control = 3;
nv->termination.auto_term_support = 1;
/*
* Set default FIFO magic - What appropriate values would be here
* is unknown. This is what I have found testing with 12160s.
*
* Now, I would love the magic decoder ring for this one, the
* header file provided by QLogic seems to be bogus or incomplete
* at best.
*/
nv->isp_config.burst_enable = 1;
if (IS_ISP1040(ha))
nv->isp_config.fifo_threshold |= 3;
else
nv->isp_config.fifo_threshold |= 4;
if (IS_ISP1x160(ha))
nv->isp_parameter = 0x01; /* fast memory enable */
for (bus = 0; bus < MAX_BUSES; bus++) {
nv->bus[bus].config_1.initiator_id = 7;
nv->bus[bus].config_2.req_ack_active_negation = 1;
nv->bus[bus].config_2.data_line_active_negation = 1;
nv->bus[bus].selection_timeout = 250;
nv->bus[bus].max_queue_depth = 32;
if (IS_ISP1040(ha)) {
nv->bus[bus].bus_reset_delay = 3;
nv->bus[bus].config_2.async_data_setup_time = 6;
nv->bus[bus].retry_delay = 1;
} else {
nv->bus[bus].bus_reset_delay = 5;
nv->bus[bus].config_2.async_data_setup_time = 8;
}
for (target = 0; target < MAX_TARGETS; target++)
qla1280_set_target_defaults(ha, bus, target);
}
}
static int
qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
{
struct nvram *nv = &ha->nvram;
uint16_t mb[MAILBOX_REGISTER_COUNT];
int status, lun;
uint16_t flag;
/* Set Target Parameters. */
mb[0] = MBC_SET_TARGET_PARAMETERS;
mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
/*
* Do not enable sync and ppr for the initial INQUIRY run. We
* enable this later if we determine the target actually
* supports it.
*/
mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
| TP_WIDE | TP_PARITY | TP_DISCONNECT);
if (IS_ISP1x160(ha))
mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
else
mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
mb[3] |= nv->bus[bus].target[target].sync_period;
status = qla1280_mailbox_command(ha, 0x0f, mb);
/* Save Tag queuing enable flag. */
flag = (BIT_0 << target);
if (nv->bus[bus].target[target].parameter.tag_queuing)
ha->bus_settings[bus].qtag_enables |= flag;
/* Save Device enable flag. */
if (IS_ISP1x160(ha)) {
if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
ha->bus_settings[bus].device_enables |= flag;
ha->bus_settings[bus].lun_disables |= 0;
} else {
if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
ha->bus_settings[bus].device_enables |= flag;
/* Save LUN disable flag. */
if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
ha->bus_settings[bus].lun_disables |= flag;
}
/* Set Device Queue Parameters. */
for (lun = 0; lun < MAX_LUNS; lun++) {
mb[0] = MBC_SET_DEVICE_QUEUE;
mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
mb[1] |= lun;
mb[2] = nv->bus[bus].max_queue_depth;
mb[3] = nv->bus[bus].target[target].execution_throttle;
status |= qla1280_mailbox_command(ha, 0x0f, mb);
}
return status;
}
static int
qla1280_config_bus(struct scsi_qla_host *ha, int bus)
{
struct nvram *nv = &ha->nvram;
uint16_t mb[MAILBOX_REGISTER_COUNT];
int target, status;
/* SCSI Reset Disable. */
ha->bus_settings[bus].disable_scsi_reset =
nv->bus[bus].config_1.scsi_reset_disable;
/* Initiator ID. */
ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
mb[0] = MBC_SET_INITIATOR_ID;
mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
ha->bus_settings[bus].id;
status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
/* Reset Delay. */
ha->bus_settings[bus].bus_reset_delay =
nv->bus[bus].bus_reset_delay;
/* Command queue depth per device. */
ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
/* Set target parameters. */
for (target = 0; target < MAX_TARGETS; target++)
status |= qla1280_config_target(ha, bus, target);
return status;
}
static int
qla1280_nvram_config(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
struct nvram *nv = &ha->nvram;
int bus, target, status = 0;
uint16_t mb[MAILBOX_REGISTER_COUNT];
ENTER("qla1280_nvram_config");
if (ha->nvram_valid) {
/* Always force AUTO sense for LINUX SCSI */
for (bus = 0; bus < MAX_BUSES; bus++)
for (target = 0; target < MAX_TARGETS; target++) {
nv->bus[bus].target[target].parameter.
auto_request_sense = 1;
}
} else {
qla1280_set_defaults(ha);
}
qla1280_print_settings(nv);
/* Disable RISC load of firmware. */
ha->flags.disable_risc_code_load =
nv->cntr_flags_1.disable_loading_risc_code;
if (IS_ISP1040(ha)) {
uint16_t hwrev, cfg1, cdma_conf;
hwrev = RD_REG_WORD(&reg->cfg_0) & ISP_CFG0_HWMSK;
cfg1 = RD_REG_WORD(&reg->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
cdma_conf = RD_REG_WORD(&reg->cdma_cfg);
/* Busted fifo, says mjacob. */
if (hwrev != ISP_CFG0_1040A)
cfg1 |= nv->isp_config.fifo_threshold << 4;
cfg1 |= nv->isp_config.burst_enable << 2;
WRT_REG_WORD(&reg->cfg_1, cfg1);
WRT_REG_WORD(&reg->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
WRT_REG_WORD(&reg->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
} else {
uint16_t cfg1, term;
/* Set ISP hardware DMA burst */
cfg1 = nv->isp_config.fifo_threshold << 4;
cfg1 |= nv->isp_config.burst_enable << 2;
/* Enable DMA arbitration on dual channel controllers */
if (ha->ports > 1)
cfg1 |= BIT_13;
WRT_REG_WORD(&reg->cfg_1, cfg1);
/* Set SCSI termination. */
WRT_REG_WORD(&reg->gpio_enable,
BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
term = nv->termination.scsi_bus_1_control;
term |= nv->termination.scsi_bus_0_control << 2;
term |= nv->termination.auto_term_support << 7;
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
WRT_REG_WORD(&reg->gpio_data, term);
}
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
/* ISP parameter word. */
mb[0] = MBC_SET_SYSTEM_PARAMETER;
mb[1] = nv->isp_parameter;
status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
if (IS_ISP1x40(ha)) {
/* clock rate - for qla1240 and older, only */
mb[0] = MBC_SET_CLOCK_RATE;
mb[1] = 40;
status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
}
/* Firmware feature word. */
mb[0] = MBC_SET_FIRMWARE_FEATURES;
mb[1] = nv->firmware_feature.f.enable_fast_posting;
mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
/* Retry count and delay. */
mb[0] = MBC_SET_RETRY_COUNT;
mb[1] = nv->bus[0].retry_count;
mb[2] = nv->bus[0].retry_delay;
mb[6] = nv->bus[1].retry_count;
mb[7] = nv->bus[1].retry_delay;
status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
BIT_1 | BIT_0, &mb[0]);
/* ASYNC data setup time. */
mb[0] = MBC_SET_ASYNC_DATA_SETUP;
mb[1] = nv->bus[0].config_2.async_data_setup_time;
mb[2] = nv->bus[1].config_2.async_data_setup_time;
status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
/* Active negation states. */
mb[0] = MBC_SET_ACTIVE_NEGATION;
mb[1] = 0;
if (nv->bus[0].config_2.req_ack_active_negation)
mb[1] |= BIT_5;
if (nv->bus[0].config_2.data_line_active_negation)
mb[1] |= BIT_4;
mb[2] = 0;
if (nv->bus[1].config_2.req_ack_active_negation)
mb[2] |= BIT_5;
if (nv->bus[1].config_2.data_line_active_negation)
mb[2] |= BIT_4;
status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
/* thingy */
mb[0] = MBC_SET_PCI_CONTROL;
mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
mb[0] = MBC_SET_TAG_AGE_LIMIT;
mb[1] = 8;
status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
/* Selection timeout. */
mb[0] = MBC_SET_SELECTION_TIMEOUT;
mb[1] = nv->bus[0].selection_timeout;
mb[2] = nv->bus[1].selection_timeout;
status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
for (bus = 0; bus < ha->ports; bus++)
status |= qla1280_config_bus(ha, bus);
if (status)
dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
LEAVE("qla1280_nvram_config");
return status;
}
/*
* Get NVRAM data word
* Calculates word position in NVRAM and calls request routine to
* get the word from NVRAM.
*
* Input:
* ha = adapter block pointer.
* address = NVRAM word address.
*
* Returns:
* data word.
*/
static uint16_t
qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
{
uint32_t nv_cmd;
uint16_t data;
nv_cmd = address << 16;
nv_cmd |= NV_READ_OP;
data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
"0x%x", data);
return data;
}
/*
* NVRAM request
* Sends read command to NVRAM and gets data from NVRAM.
*
* Input:
* ha = adapter block pointer.
* nv_cmd = Bit 26 = start bit
* Bit 25, 24 = opcode
* Bit 23-16 = address
* Bit 15-0 = write data
*
* Returns:
* data word.
*/
static uint16_t
qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
{
struct device_reg __iomem *reg = ha->iobase;
int cnt;
uint16_t data = 0;
uint16_t reg_data;
/* Send command to NVRAM. */
nv_cmd <<= 5;
for (cnt = 0; cnt < 11; cnt++) {
if (nv_cmd & BIT_31)
qla1280_nv_write(ha, NV_DATA_OUT);
else
qla1280_nv_write(ha, 0);
nv_cmd <<= 1;
}
/* Read data from NVRAM. */
for (cnt = 0; cnt < 16; cnt++) {
WRT_REG_WORD(&reg->nvram, (NV_SELECT | NV_CLOCK));
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
data <<= 1;
reg_data = RD_REG_WORD(&reg->nvram);
if (reg_data & NV_DATA_IN)
data |= BIT_0;
WRT_REG_WORD(&reg->nvram, NV_SELECT);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
}
/* Deselect chip. */
WRT_REG_WORD(&reg->nvram, NV_DESELECT);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
return data;
}
static void
qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
{
struct device_reg __iomem *reg = ha->iobase;
WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
WRT_REG_WORD(&reg->nvram, data | NV_SELECT | NV_CLOCK);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
NVRAM_DELAY();
}
/*
* Mailbox Command
* Issue mailbox command and waits for completion.
*
* Input:
* ha = adapter block pointer.
* mr = mailbox registers to load.
* mb = data pointer for mailbox registers.
*
* Output:
* mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
*
* Returns:
* 0 = success
*/
static int
qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
{
struct device_reg __iomem *reg = ha->iobase;
int status = 0;
int cnt;
uint16_t *optr, *iptr;
uint16_t __iomem *mptr;
DECLARE_COMPLETION_ONSTACK(wait);
ENTER("qla1280_mailbox_command");
if (ha->mailbox_wait) {
printk(KERN_ERR "Warning mailbox wait already in use!\n");
}
ha->mailbox_wait = &wait;
/*
* We really should start out by verifying that the mailbox is
* available before starting sending the command data
*/
/* Load mailbox registers. */
mptr = (uint16_t __iomem *) &reg->mailbox0;
iptr = mb;
for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
if (mr & BIT_0) {
WRT_REG_WORD(mptr, (*iptr));
}
mr >>= 1;
mptr++;
iptr++;
}
/* Issue set host interrupt command. */
/* set up a timer just in case we're really jammed */
timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
spin_unlock_irq(ha->host->host_lock);
WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
qla1280_debounce_register(&reg->istatus);
wait_for_completion(&wait);
del_timer_sync(&ha->mailbox_timer);
spin_lock_irq(ha->host->host_lock);
ha->mailbox_wait = NULL;
/* Check for mailbox command timeout. */
if (ha->mailbox_out[0] != MBS_CMD_CMP) {
printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
"mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
"0x%04x\n",
mb[0], ha->mailbox_out[0], RD_REG_WORD(&reg->istatus));
printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
RD_REG_WORD(&reg->mailbox0), RD_REG_WORD(&reg->mailbox1),
RD_REG_WORD(&reg->mailbox2), RD_REG_WORD(&reg->mailbox3));
printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
RD_REG_WORD(&reg->mailbox4), RD_REG_WORD(&reg->mailbox5),
RD_REG_WORD(&reg->mailbox6), RD_REG_WORD(&reg->mailbox7));
status = 1;
}
/* Load return mailbox registers. */
optr = mb;
iptr = (uint16_t *) &ha->mailbox_out[0];
mr = MAILBOX_REGISTER_COUNT;
memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
if (ha->flags.reset_marker)
qla1280_rst_aen(ha);
if (status)
dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
"0x%x ****\n", mb[0]);
LEAVE("qla1280_mailbox_command");
return status;
}
/*
* qla1280_poll
* Polls ISP for interrupts.
*
* Input:
* ha = adapter block pointer.
*/
static void
qla1280_poll(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
uint16_t data;
LIST_HEAD(done_q);
/* ENTER("qla1280_poll"); */
/* Check for pending interrupts. */
data = RD_REG_WORD(&reg->istatus);
if (data & RISC_INT)
qla1280_isr(ha, &done_q);
if (!ha->mailbox_wait) {
if (ha->flags.reset_marker)
qla1280_rst_aen(ha);
}
if (!list_empty(&done_q))
qla1280_done(ha);
/* LEAVE("qla1280_poll"); */
}
/*
* qla1280_bus_reset
* Issue SCSI bus reset.
*
* Input:
* ha = adapter block pointer.
* bus = SCSI bus number.
*
* Returns:
* 0 = success
*/
static int
qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
uint16_t reset_delay;
int status;
dprintk(3, "qla1280_bus_reset: entered\n");
if (qla1280_verbose)
printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
ha->host_no, bus);
reset_delay = ha->bus_settings[bus].bus_reset_delay;
mb[0] = MBC_BUS_RESET;
mb[1] = reset_delay;
mb[2] = (uint16_t) bus;
status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
if (status) {
if (ha->bus_settings[bus].failed_reset_count > 2)
ha->bus_settings[bus].scsi_bus_dead = 1;
ha->bus_settings[bus].failed_reset_count++;
} else {
spin_unlock_irq(ha->host->host_lock);
ssleep(reset_delay);
spin_lock_irq(ha->host->host_lock);
ha->bus_settings[bus].scsi_bus_dead = 0;
ha->bus_settings[bus].failed_reset_count = 0;
ha->bus_settings[bus].reset_marker = 0;
/* Issue marker command. */
qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
}
/*
* We should probably call qla1280_set_target_parameters()
* here as well for all devices on the bus.
*/
if (status)
dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
else
dprintk(3, "qla1280_bus_reset: exiting normally\n");
return status;
}
/*
* qla1280_device_reset
* Issue bus device reset message to the target.
*
* Input:
* ha = adapter block pointer.
* bus = SCSI BUS number.
* target = SCSI ID.
*
* Returns:
* 0 = success
*/
static int
qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
int status;
ENTER("qla1280_device_reset");
mb[0] = MBC_ABORT_TARGET;
mb[1] = (bus ? (target | BIT_7) : target) << 8;
mb[2] = 1;
status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
/* Issue marker command. */
qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
if (status)
dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
LEAVE("qla1280_device_reset");
return status;
}
/*
* qla1280_abort_command
* Abort command aborts a specified IOCB.
*
* Input:
* ha = adapter block pointer.
* sp = SB structure pointer.
*
* Returns:
* 0 = success
*/
static int
qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
unsigned int bus, target, lun;
int status;
ENTER("qla1280_abort_command");
bus = SCSI_BUS_32(sp->cmd);
target = SCSI_TCN_32(sp->cmd);
lun = SCSI_LUN_32(sp->cmd);
sp->flags |= SRB_ABORT_PENDING;
mb[0] = MBC_ABORT_COMMAND;
mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
mb[2] = handle >> 16;
mb[3] = handle & 0xffff;
status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
if (status) {
dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
sp->flags &= ~SRB_ABORT_PENDING;
}
LEAVE("qla1280_abort_command");
return status;
}
/*
* qla1280_reset_adapter
* Reset adapter.
*
* Input:
* ha = adapter block pointer.
*/
static void
qla1280_reset_adapter(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
ENTER("qla1280_reset_adapter");
/* Disable ISP chip */
ha->flags.online = 0;
WRT_REG_WORD(&reg->ictrl, ISP_RESET);
WRT_REG_WORD(&reg->host_cmd,
HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
RD_REG_WORD(&reg->id_l); /* Flush PCI write */
LEAVE("qla1280_reset_adapter");
}
/*
* Issue marker command.
* Function issues marker IOCB.
*
* Input:
* ha = adapter block pointer.
* bus = SCSI BUS number
* id = SCSI ID
* lun = SCSI LUN
* type = marker modifier
*/
static void
qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
{
struct mrk_entry *pkt;
ENTER("qla1280_marker");
/* Get request packet. */
if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
pkt->entry_type = MARKER_TYPE;
pkt->lun = (uint8_t) lun;
pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
pkt->modifier = type;
pkt->entry_status = 0;
/* Issue command to ISP */
qla1280_isp_cmd(ha);
}
LEAVE("qla1280_marker");
}
/*
* qla1280_64bit_start_scsi
* The start SCSI is responsible for building request packets on
* request ring and modifying ISP input pointer.
*
* Input:
* ha = adapter block pointer.
* sp = SB structure pointer.
*
* Returns:
* 0 = success, was able to issue command.
*/
#ifdef QLA_64BIT_PTR
static int
qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
{
struct device_reg __iomem *reg = ha->iobase;
struct scsi_cmnd *cmd = sp->cmd;
cmd_a64_entry_t *pkt;
__le32 *dword_ptr;
dma_addr_t dma_handle;
int status = 0;
int cnt;
int req_cnt;
int seg_cnt;
u8 dir;
ENTER("qla1280_64bit_start_scsi:");
/* Calculate number of entries and segments required. */
req_cnt = 1;
seg_cnt = scsi_dma_map(cmd);
if (seg_cnt > 0) {
if (seg_cnt > 2) {
req_cnt += (seg_cnt - 2) / 5;
if ((seg_cnt - 2) % 5)
req_cnt++;
}
} else if (seg_cnt < 0) {
status = 1;
goto out;
}
if ((req_cnt + 2) >= ha->req_q_cnt) {
/* Calculate number of free request entries. */
cnt = RD_REG_WORD(&reg->mailbox4);
if (ha->req_ring_index < cnt)
ha->req_q_cnt = cnt - ha->req_ring_index;
else
ha->req_q_cnt =
REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
}
dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
ha->req_q_cnt, seg_cnt);
/* If room for request in request ring. */
if ((req_cnt + 2) >= ha->req_q_cnt) {
status = SCSI_MLQUEUE_HOST_BUSY;
dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
"0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
req_cnt);
goto out;
}
/* Check for room in outstanding command list. */
for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
ha->outstanding_cmds[cnt] != NULL; cnt++);
if (cnt >= MAX_OUTSTANDING_COMMANDS) {
status = SCSI_MLQUEUE_HOST_BUSY;
dprintk(2, "qla1280_start_scsi: NO ROOM IN "
"OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
goto out;
}
ha->outstanding_cmds[cnt] = sp;
ha->req_q_cnt -= req_cnt;
CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
dprintk(2, " bus %i, target %i, lun %i\n",
SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
/*
* Build command packet.
*/
pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
pkt->entry_type = COMMAND_A64_TYPE;
pkt->entry_count = (uint8_t) req_cnt;
pkt->sys_define = (uint8_t) ha->req_ring_index;
pkt->entry_status = 0;
pkt->handle = cpu_to_le32(cnt);
/* Zero out remaining portion of packet. */
memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
/* Set ISP command timeout. */
pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
/* Set device target ID and LUN */
pkt->lun = SCSI_LUN_32(cmd);
pkt->target = SCSI_BUS_32(cmd) ?
(SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
/* Enable simple tag queuing if device supports it. */
if (cmd->device->simple_tags)
pkt->control_flags |= cpu_to_le16(BIT_3);
/* Load SCSI command packet. */
pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
/* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
/* Set transfer direction. */
dir = qla1280_data_direction(cmd);
pkt->control_flags |= cpu_to_le16(dir);
/* Set total data segment count. */
pkt->dseg_count = cpu_to_le16(seg_cnt);
/*
* Load data segments.
*/
if (seg_cnt) { /* If data transfer. */
struct scatterlist *sg, *s;
int remseg = seg_cnt;
sg = scsi_sglist(cmd);
/* Setup packet address segment pointer. */
dword_ptr = (u32 *)&pkt->dseg_0_address;
/* Load command entry data segments. */
for_each_sg(sg, s, seg_cnt, cnt) {
if (cnt == 2)
break;
dma_handle = sg_dma_address(s);
*dword_ptr++ =
cpu_to_le32(lower_32_bits(dma_handle));
*dword_ptr++ =
cpu_to_le32(upper_32_bits(dma_handle));
*dword_ptr++ = cpu_to_le32(sg_dma_len(s));
dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
cpu_to_le32(upper_32_bits(dma_handle)),
cpu_to_le32(lower_32_bits(dma_handle)),
cpu_to_le32(sg_dma_len(sg_next(s))));
remseg--;
}
dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
"command packet data - b %i, t %i, l %i \n",
SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
SCSI_LUN_32(cmd));
qla1280_dump_buffer(5, (char *)pkt,
REQUEST_ENTRY_SIZE);
/*
* Build continuation packets.
*/
dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
"remains\n", seg_cnt);
while (remseg > 0) {
/* Update sg start */
sg = s;
/* Adjust ring index. */
ha->req_ring_index++;
if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
ha->req_ring_index = 0;
ha->request_ring_ptr =
ha->request_ring;
} else
ha->request_ring_ptr++;
pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
/* Zero out packet. */
memset(pkt, 0, REQUEST_ENTRY_SIZE);
/* Load packet defaults. */
((struct cont_a64_entry *) pkt)->entry_type =
CONTINUE_A64_TYPE;
((struct cont_a64_entry *) pkt)->entry_count = 1;
((struct cont_a64_entry *) pkt)->sys_define =
(uint8_t)ha->req_ring_index;
/* Setup packet address segment pointer. */
dword_ptr =
(u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
/* Load continuation entry data segments. */
for_each_sg(sg, s, remseg, cnt) {
if (cnt == 5)
break;
dma_handle = sg_dma_address(s);
*dword_ptr++ =
cpu_to_le32(lower_32_bits(dma_handle));
*dword_ptr++ =
cpu_to_le32(upper_32_bits(dma_handle));
*dword_ptr++ =
cpu_to_le32(sg_dma_len(s));
dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
cpu_to_le32(upper_32_bits(dma_handle)),
cpu_to_le32(lower_32_bits(dma_handle)),
cpu_to_le32(sg_dma_len(s)));
}
remseg -= cnt;
dprintk(5, "qla1280_64bit_start_scsi: "
"continuation packet data - b %i, t "
"%i, l %i \n", SCSI_BUS_32(cmd),
SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
qla1280_dump_buffer(5, (char *)pkt,
REQUEST_ENTRY_SIZE);
}
} else { /* No data transfer */
dprintk(5, "qla1280_64bit_start_scsi: No data, command "
"packet data - b %i, t %i, l %i \n",
SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
}
/* Adjust ring index. */
ha->req_ring_index++;
if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
ha->req_ring_index = 0;
ha->request_ring_ptr = ha->request_ring;
} else
ha->request_ring_ptr++;
/* Set chip new ring index. */
dprintk(2,
"qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
sp->flags |= SRB_SENT;
ha->actthreads++;
WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
out:
if (status)
dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
else
dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
return status;
}
#else /* !QLA_64BIT_PTR */
/*
* qla1280_32bit_start_scsi
* The start SCSI is responsible for building request packets on
* request ring and modifying ISP input pointer.
*
* The Qlogic firmware interface allows every queue slot to have a SCSI
* command and up to 4 scatter/gather (SG) entries. If we need more
* than 4 SG entries, then continuation entries are used that can
* hold another 7 entries each. The start routine determines if there
* is eought empty slots then build the combination of requests to
* fulfill the OS request.
*
* Input:
* ha = adapter block pointer.
* sp = SCSI Request Block structure pointer.
*
* Returns:
* 0 = success, was able to issue command.
*/
static int
qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
{
struct device_reg __iomem *reg = ha->iobase;
struct scsi_cmnd *cmd = sp->cmd;
struct cmd_entry *pkt;
__le32 *dword_ptr;
int status = 0;
int cnt;
int req_cnt;
int seg_cnt;
u8 dir;
ENTER("qla1280_32bit_start_scsi");
dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
cmd->cmnd[0]);
/* Calculate number of entries and segments required. */
req_cnt = 1;
seg_cnt = scsi_dma_map(cmd);
if (seg_cnt) {
/*
* if greater than four sg entries then we need to allocate
* continuation entries
*/
if (seg_cnt > 4) {
req_cnt += (seg_cnt - 4) / 7;
if ((seg_cnt - 4) % 7)
req_cnt++;
}
dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
cmd, seg_cnt, req_cnt);
} else if (seg_cnt < 0) {
status = 1;
goto out;
}
if ((req_cnt + 2) >= ha->req_q_cnt) {
/* Calculate number of free request entries. */
cnt = RD_REG_WORD(&reg->mailbox4);
if (ha->req_ring_index < cnt)
ha->req_q_cnt = cnt - ha->req_ring_index;
else
ha->req_q_cnt =
REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
}
dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
ha->req_q_cnt, seg_cnt);
/* If room for request in request ring. */
if ((req_cnt + 2) >= ha->req_q_cnt) {
status = SCSI_MLQUEUE_HOST_BUSY;
dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
"req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
ha->req_q_cnt, req_cnt);
goto out;
}
/* Check for empty slot in outstanding command list. */
for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
ha->outstanding_cmds[cnt]; cnt++);
if (cnt >= MAX_OUTSTANDING_COMMANDS) {
status = SCSI_MLQUEUE_HOST_BUSY;
dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
"ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
goto out;
}
CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
ha->outstanding_cmds[cnt] = sp;
ha->req_q_cnt -= req_cnt;
/*
* Build command packet.
*/
pkt = (struct cmd_entry *) ha->request_ring_ptr;
pkt->entry_type = COMMAND_TYPE;
pkt->entry_count = (uint8_t) req_cnt;
pkt->sys_define = (uint8_t) ha->req_ring_index;
pkt->entry_status = 0;
pkt->handle = cpu_to_le32(cnt);
/* Zero out remaining portion of packet. */
memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
/* Set ISP command timeout. */
pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
/* Set device target ID and LUN */
pkt->lun = SCSI_LUN_32(cmd);
pkt->target = SCSI_BUS_32(cmd) ?
(SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
/* Enable simple tag queuing if device supports it. */
if (cmd->device->simple_tags)
pkt->control_flags |= cpu_to_le16(BIT_3);
/* Load SCSI command packet. */
pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
/*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
/* Set transfer direction. */
dir = qla1280_data_direction(cmd);
pkt->control_flags |= cpu_to_le16(dir);
/* Set total data segment count. */
pkt->dseg_count = cpu_to_le16(seg_cnt);
/*
* Load data segments.
*/
if (seg_cnt) {
struct scatterlist *sg, *s;
int remseg = seg_cnt;
sg = scsi_sglist(cmd);
/* Setup packet address segment pointer. */
dword_ptr = &pkt->dseg_0_address;
dprintk(3, "Building S/G data segments..\n");
qla1280_dump_buffer(1, (char *)sg, 4 * 16);
/* Load command entry data segments. */
for_each_sg(sg, s, seg_cnt, cnt) {
if (cnt == 4)
break;
*dword_ptr++ =
cpu_to_le32(lower_32_bits(sg_dma_address(s)));
*dword_ptr++ = cpu_to_le32(sg_dma_len(s));
dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
(lower_32_bits(sg_dma_address(s))),
(sg_dma_len(s)));
remseg--;
}
/*
* Build continuation packets.
*/
dprintk(3, "S/G Building Continuation"
"...seg_cnt=0x%x remains\n", seg_cnt);
while (remseg > 0) {
/* Continue from end point */
sg = s;
/* Adjust ring index. */
ha->req_ring_index++;
if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
ha->req_ring_index = 0;
ha->request_ring_ptr =
ha->request_ring;
} else
ha->request_ring_ptr++;
pkt = (struct cmd_entry *)ha->request_ring_ptr;
/* Zero out packet. */
memset(pkt, 0, REQUEST_ENTRY_SIZE);
/* Load packet defaults. */
((struct cont_entry *) pkt)->
entry_type = CONTINUE_TYPE;
((struct cont_entry *) pkt)->entry_count = 1;
((struct cont_entry *) pkt)->sys_define =
(uint8_t) ha->req_ring_index;
/* Setup packet address segment pointer. */
dword_ptr =
&((struct cont_entry *) pkt)->dseg_0_address;
/* Load continuation entry data segments. */
for_each_sg(sg, s, remseg, cnt) {
if (cnt == 7)
break;
*dword_ptr++ =
cpu_to_le32(lower_32_bits(sg_dma_address(s)));
*dword_ptr++ =
cpu_to_le32(sg_dma_len(s));
dprintk(1,
"S/G Segment Cont. phys_addr=0x%x, "
"len=0x%x\n",
cpu_to_le32(lower_32_bits(sg_dma_address(s))),
cpu_to_le32(sg_dma_len(s)));
}
remseg -= cnt;
dprintk(5, "qla1280_32bit_start_scsi: "
"continuation packet data - "
"scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
qla1280_dump_buffer(5, (char *)pkt,
REQUEST_ENTRY_SIZE);
}
} else { /* No data transfer at all */
dprintk(5, "qla1280_32bit_start_scsi: No data, command "
"packet data - \n");
qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
}
dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
REQUEST_ENTRY_SIZE);
/* Adjust ring index. */
ha->req_ring_index++;
if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
ha->req_ring_index = 0;
ha->request_ring_ptr = ha->request_ring;
} else
ha->request_ring_ptr++;
/* Set chip new ring index. */
dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
"for pending command\n");
sp->flags |= SRB_SENT;
ha->actthreads++;
WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
out:
if (status)
dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
LEAVE("qla1280_32bit_start_scsi");
return status;
}
#endif
/*
* qla1280_req_pkt
* Function is responsible for locking ring and
* getting a zeroed out request packet.
*
* Input:
* ha = adapter block pointer.
*
* Returns:
* 0 = failed to get slot.
*/
static request_t *
qla1280_req_pkt(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
request_t *pkt = NULL;
int cnt;
uint32_t timer;
ENTER("qla1280_req_pkt");
/*
* This can be called from interrupt context, damn it!!!
*/
/* Wait for 30 seconds for slot. */
for (timer = 15000000; timer; timer--) {
if (ha->req_q_cnt > 0) {
/* Calculate number of free request entries. */
cnt = RD_REG_WORD(&reg->mailbox4);
if (ha->req_ring_index < cnt)
ha->req_q_cnt = cnt - ha->req_ring_index;
else
ha->req_q_cnt =
REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
}
/* Found empty request ring slot? */
if (ha->req_q_cnt > 0) {
ha->req_q_cnt--;
pkt = ha->request_ring_ptr;
/* Zero out packet. */
memset(pkt, 0, REQUEST_ENTRY_SIZE);
/*
* How can this be right when we have a ring
* size of 512???
*/
/* Set system defined field. */
pkt->sys_define = (uint8_t) ha->req_ring_index;
/* Set entry count. */
pkt->entry_count = 1;
break;
}
udelay(2); /* 10 */
/* Check for pending interrupts. */
qla1280_poll(ha);
}
if (!pkt)
dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
else
dprintk(3, "qla1280_req_pkt: exiting normally\n");
return pkt;
}
/*
* qla1280_isp_cmd
* Function is responsible for modifying ISP input pointer.
* Releases ring lock.
*
* Input:
* ha = adapter block pointer.
*/
static void
qla1280_isp_cmd(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
ENTER("qla1280_isp_cmd");
dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
REQUEST_ENTRY_SIZE);
/* Adjust ring index. */
ha->req_ring_index++;
if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
ha->req_ring_index = 0;
ha->request_ring_ptr = ha->request_ring;
} else
ha->request_ring_ptr++;
/*
* Update request index to mailbox4 (Request Queue In).
*/
WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
LEAVE("qla1280_isp_cmd");
}
/****************************************************************************/
/* Interrupt Service Routine. */
/****************************************************************************/
/****************************************************************************
* qla1280_isr
* Calls I/O done on command completion.
*
* Input:
* ha = adapter block pointer.
* done_q = done queue.
****************************************************************************/
static void
qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
{
struct device_reg __iomem *reg = ha->iobase;
struct response *pkt;
struct srb *sp = NULL;
uint16_t mailbox[MAILBOX_REGISTER_COUNT];
uint16_t *wptr;
uint32_t index;
u16 istatus;
ENTER("qla1280_isr");
istatus = RD_REG_WORD(&reg->istatus);
if (!(istatus & (RISC_INT | PCI_INT)))
return;
/* Save mailbox register 5 */
mailbox[5] = RD_REG_WORD(&reg->mailbox5);
/* Check for mailbox interrupt. */
mailbox[0] = RD_REG_WORD_dmasync(&reg->semaphore);
if (mailbox[0] & BIT_0) {
/* Get mailbox data. */
/* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
wptr = &mailbox[0];
*wptr++ = RD_REG_WORD(&reg->mailbox0);
*wptr++ = RD_REG_WORD(&reg->mailbox1);
*wptr = RD_REG_WORD(&reg->mailbox2);
if (mailbox[0] != MBA_SCSI_COMPLETION) {
wptr++;
*wptr++ = RD_REG_WORD(&reg->mailbox3);
*wptr++ = RD_REG_WORD(&reg->mailbox4);
wptr++;
*wptr++ = RD_REG_WORD(&reg->mailbox6);
*wptr = RD_REG_WORD(&reg->mailbox7);
}
/* Release mailbox registers. */
WRT_REG_WORD(&reg->semaphore, 0);
WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
mailbox[0]);
/* Handle asynchronous event */
switch (mailbox[0]) {
case MBA_SCSI_COMPLETION: /* Response completion */
dprintk(5, "qla1280_isr: mailbox SCSI response "
"completion\n");
if (ha->flags.online) {
/* Get outstanding command index. */
index = mailbox[2] << 16 | mailbox[1];
/* Validate handle. */
if (index < MAX_OUTSTANDING_COMMANDS)
sp = ha->outstanding_cmds[index];
else
sp = NULL;
if (sp) {
/* Free outstanding command slot. */
ha->outstanding_cmds[index] = NULL;
/* Save ISP completion status */
CMD_RESULT(sp->cmd) = 0;
CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
/* Place block on done queue */
list_add_tail(&sp->list, done_q);
} else {
/*
* If we get here we have a real problem!
*/
printk(KERN_WARNING
"qla1280: ISP invalid handle\n");
}
}
break;
case MBA_BUS_RESET: /* SCSI Bus Reset */
ha->flags.reset_marker = 1;
index = mailbox[6] & BIT_0;
ha->bus_settings[index].reset_marker = 1;
printk(KERN_DEBUG "qla1280_isr(): index %i "
"asynchronous BUS_RESET\n", index);
break;
case MBA_SYSTEM_ERR: /* System Error */
printk(KERN_WARNING
"qla1280: ISP System Error - mbx1=%xh, mbx2="
"%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
mailbox[3]);
break;
case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
printk(KERN_WARNING
"qla1280: ISP Request Transfer Error\n");
break;
case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
printk(KERN_WARNING
"qla1280: ISP Response Transfer Error\n");
break;
case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
break;
case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
dprintk(2,
"qla1280_isr: asynchronous TIMEOUT_RESET\n");
break;
case MBA_DEVICE_RESET: /* Bus Device Reset */
printk(KERN_INFO "qla1280_isr(): asynchronous "
"BUS_DEVICE_RESET\n");
ha->flags.reset_marker = 1;
index = mailbox[6] & BIT_0;
ha->bus_settings[index].reset_marker = 1;
break;
case MBA_BUS_MODE_CHANGE:
dprintk(2,
"qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
break;
default:
/* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
if (mailbox[0] < MBA_ASYNC_EVENT) {
wptr = &mailbox[0];
memcpy((uint16_t *) ha->mailbox_out, wptr,
MAILBOX_REGISTER_COUNT *
sizeof(uint16_t));
if(ha->mailbox_wait != NULL)
complete(ha->mailbox_wait);
}
break;
}
} else {
WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
}
/*
* We will receive interrupts during mailbox testing prior to
* the card being marked online, hence the double check.
*/
if (!(ha->flags.online && !ha->mailbox_wait)) {
dprintk(2, "qla1280_isr: Response pointer Error\n");
goto out;
}
if (mailbox[5] >= RESPONSE_ENTRY_CNT)
goto out;
while (ha->rsp_ring_index != mailbox[5]) {
pkt = ha->response_ring_ptr;
dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
" = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
dprintk(5,"qla1280_isr: response packet data\n");
qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
if (pkt->entry_type == STATUS_TYPE) {
if ((le16_to_cpu(pkt->scsi_status) & 0xff)
|| pkt->comp_status || pkt->entry_status) {
dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
"0x%x mailbox[5] = 0x%x, comp_status "
"= 0x%x, scsi_status = 0x%x\n",
ha->rsp_ring_index, mailbox[5],
le16_to_cpu(pkt->comp_status),
le16_to_cpu(pkt->scsi_status));
}
} else {
dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
"0x%x, mailbox[5] = 0x%x\n",
ha->rsp_ring_index, mailbox[5]);
dprintk(2, "qla1280_isr: response packet data\n");
qla1280_dump_buffer(2, (char *)pkt,
RESPONSE_ENTRY_SIZE);
}
if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
dprintk(2, "status: Cmd %p, handle %i\n",
ha->outstanding_cmds[pkt->handle]->cmd,
pkt->handle);
if (pkt->entry_type == STATUS_TYPE)
qla1280_status_entry(ha, pkt, done_q);
else
qla1280_error_entry(ha, pkt, done_q);
/* Adjust ring index. */
ha->rsp_ring_index++;
if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
ha->rsp_ring_index = 0;
ha->response_ring_ptr = ha->response_ring;
} else
ha->response_ring_ptr++;
WRT_REG_WORD(&reg->mailbox5, ha->rsp_ring_index);
}
}
out:
LEAVE("qla1280_isr");
}
/*
* qla1280_rst_aen
* Processes asynchronous reset.
*
* Input:
* ha = adapter block pointer.
*/
static void
qla1280_rst_aen(struct scsi_qla_host *ha)
{
uint8_t bus;
ENTER("qla1280_rst_aen");
if (ha->flags.online && !ha->flags.reset_active &&
!ha->flags.abort_isp_active) {
ha->flags.reset_active = 1;
while (ha->flags.reset_marker) {
/* Issue marker command. */
ha->flags.reset_marker = 0;
for (bus = 0; bus < ha->ports &&
!ha->flags.reset_marker; bus++) {
if (ha->bus_settings[bus].reset_marker) {
ha->bus_settings[bus].reset_marker = 0;
qla1280_marker(ha, bus, 0, 0,
MK_SYNC_ALL);
}
}
}
}
LEAVE("qla1280_rst_aen");
}
/*
* qla1280_status_entry
* Processes received ISP status entry.
*
* Input:
* ha = adapter block pointer.
* pkt = entry pointer.
* done_q = done queue.
*/
static void
qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
struct list_head *done_q)
{
int sense_sz;
struct srb *sp;
struct scsi_cmnd *cmd;
uint32_t handle = le32_to_cpu(pkt->handle);
uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
uint16_t comp_status = le16_to_cpu(pkt->comp_status);
ENTER("qla1280_status_entry");
/* Validate handle. */
if (handle < MAX_OUTSTANDING_COMMANDS)
sp = ha->outstanding_cmds[handle];
else
sp = NULL;
if (!sp) {
printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
goto out;
}
/* Free outstanding command slot. */
ha->outstanding_cmds[handle] = NULL;
cmd = sp->cmd;
if (comp_status || scsi_status) {
dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
"0x%x, handle = 0x%x\n", comp_status,
scsi_status, handle);
}
/* Target busy or queue full */
if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
(scsi_status & 0xFF) == SAM_STAT_BUSY) {
CMD_RESULT(cmd) = scsi_status & 0xff;
} else {
/* Save ISP completion status */
CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
if (scsi_status & SAM_STAT_CHECK_CONDITION) {
if (comp_status != CS_ARS_FAILED) {
uint16_t req_sense_length =
le16_to_cpu(pkt->req_sense_length);
if (req_sense_length < CMD_SNSLEN(cmd))
sense_sz = req_sense_length;
else
/*
* scsi_cmnd->sense_buffer is
* 64 bytes, why only copy 63?
* This looks wrong! /Jes
*/
sense_sz = CMD_SNSLEN(cmd) - 1;
memcpy(cmd->sense_buffer,
&pkt->req_sense_data, sense_sz);
} else
sense_sz = 0;
memset(cmd->sense_buffer + sense_sz, 0,
SCSI_SENSE_BUFFERSIZE - sense_sz);
dprintk(2, "qla1280_status_entry: Check "
"condition Sense data, b %i, t %i, "
"l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
SCSI_LUN_32(cmd));
if (sense_sz)
qla1280_dump_buffer(2,
(char *)cmd->sense_buffer,
sense_sz);
}
}
CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
/* Place command on done queue. */
list_add_tail(&sp->list, done_q);
out:
LEAVE("qla1280_status_entry");
}
/*
* qla1280_error_entry
* Processes error entry.
*
* Input:
* ha = adapter block pointer.
* pkt = entry pointer.
* done_q = done queue.
*/
static void
qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
struct list_head *done_q)
{
struct srb *sp;
uint32_t handle = le32_to_cpu(pkt->handle);
ENTER("qla1280_error_entry");
if (pkt->entry_status & BIT_3)
dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
else if (pkt->entry_status & BIT_2)
dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
else if (pkt->entry_status & BIT_1)
dprintk(2, "qla1280_error_entry: FULL flag error\n");
else
dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
/* Validate handle. */
if (handle < MAX_OUTSTANDING_COMMANDS)
sp = ha->outstanding_cmds[handle];
else
sp = NULL;
if (sp) {
/* Free outstanding command slot. */
ha->outstanding_cmds[handle] = NULL;
/* Bad payload or header */
if (pkt->entry_status & (BIT_3 + BIT_2)) {
/* Bad payload or header, set error status. */
/* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
CMD_RESULT(sp->cmd) = DID_ERROR << 16;
} else if (pkt->entry_status & BIT_1) { /* FULL flag */
CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
} else {
/* Set error status. */
CMD_RESULT(sp->cmd) = DID_ERROR << 16;
}
CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
/* Place command on done queue. */
list_add_tail(&sp->list, done_q);
}
#ifdef QLA_64BIT_PTR
else if (pkt->entry_type == COMMAND_A64_TYPE) {
printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
}
#endif
LEAVE("qla1280_error_entry");
}
/*
* qla1280_abort_isp
* Resets ISP and aborts all outstanding commands.
*
* Input:
* ha = adapter block pointer.
*
* Returns:
* 0 = success
*/
static int
qla1280_abort_isp(struct scsi_qla_host *ha)
{
struct device_reg __iomem *reg = ha->iobase;
struct srb *sp;
int status = 0;
int cnt;
int bus;
ENTER("qla1280_abort_isp");
if (ha->flags.abort_isp_active || !ha->flags.online)
goto out;
ha->flags.abort_isp_active = 1;
/* Disable ISP interrupts. */
qla1280_disable_intrs(ha);
WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
RD_REG_WORD(&reg->id_l);
printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
ha->host_no);
/* Dequeue all commands in outstanding command list. */
for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
struct scsi_cmnd *cmd;
sp = ha->outstanding_cmds[cnt];
if (sp) {
cmd = sp->cmd;
CMD_RESULT(cmd) = DID_RESET << 16;
CMD_HANDLE(cmd) = COMPLETED_HANDLE;
ha->outstanding_cmds[cnt] = NULL;
list_add_tail(&sp->list, &ha->done_q);
}
}
qla1280_done(ha);
status = qla1280_load_firmware(ha);
if (status)
goto out;
/* Setup adapter based on NVRAM parameters. */
qla1280_nvram_config (ha);
status = qla1280_init_rings(ha);
if (status)
goto out;
/* Issue SCSI reset. */
for (bus = 0; bus < ha->ports; bus++)
qla1280_bus_reset(ha, bus);
ha->flags.abort_isp_active = 0;
out:
if (status) {
printk(KERN_WARNING
"qla1280: ISP error recovery failed, board disabled");
qla1280_reset_adapter(ha);
dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
}
LEAVE("qla1280_abort_isp");
return status;
}
/*
* qla1280_debounce_register
* Debounce register.
*
* Input:
* port = register address.
*
* Returns:
* register value.
*/
static u16
qla1280_debounce_register(volatile u16 __iomem * addr)
{
volatile u16 ret;
volatile u16 ret2;
ret = RD_REG_WORD(addr);
ret2 = RD_REG_WORD(addr);
if (ret == ret2)
return ret;
do {
cpu_relax();
ret = RD_REG_WORD(addr);
ret2 = RD_REG_WORD(addr);
} while (ret != ret2);
return ret;
}
/************************************************************************
* qla1280_check_for_dead_scsi_bus *
* *
* This routine checks for a dead SCSI bus *
************************************************************************/
#define SET_SXP_BANK 0x0100
#define SCSI_PHASE_INVALID 0x87FF
static int
qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
{
uint16_t config_reg, scsi_control;
struct device_reg __iomem *reg = ha->iobase;
if (ha->bus_settings[bus].scsi_bus_dead) {
WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
config_reg = RD_REG_WORD(&reg->cfg_1);
WRT_REG_WORD(&reg->cfg_1, SET_SXP_BANK);
scsi_control = RD_REG_WORD(&reg->scsiControlPins);
WRT_REG_WORD(&reg->cfg_1, config_reg);
WRT_REG_WORD(&reg->host_cmd, HC_RELEASE_RISC);
if (scsi_control == SCSI_PHASE_INVALID) {
ha->bus_settings[bus].scsi_bus_dead = 1;
return 1; /* bus is dead */
} else {
ha->bus_settings[bus].scsi_bus_dead = 0;
ha->bus_settings[bus].failed_reset_count = 0;
}
}
return 0; /* bus is not dead */
}
static void
qla1280_get_target_parameters(struct scsi_qla_host *ha,
struct scsi_device *device)
{
uint16_t mb[MAILBOX_REGISTER_COUNT];
int bus, target, lun;
bus = device->channel;
target = device->id;
lun = device->lun;
mb[0] = MBC_GET_TARGET_PARAMETERS;
mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
mb[1] <<= 8;
qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
&mb[0]);
printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
if (mb[3] != 0) {
printk(KERN_CONT " Sync: period %d, offset %d",
(mb[3] & 0xff), (mb[3] >> 8));
if (mb[2] & BIT_13)
printk(KERN_CONT ", Wide");
if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
printk(KERN_CONT ", DT");
} else
printk(KERN_CONT " Async");
if (device->simple_tags)
printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);
printk(KERN_CONT "\n");
}
#if DEBUG_QLA1280
static void
__qla1280_dump_buffer(char *b, int size)
{
int cnt;
u8 c;
printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
"Bh Ch Dh Eh Fh\n");
printk(KERN_DEBUG "---------------------------------------------"
"------------------\n");
for (cnt = 0; cnt < size;) {
c = *b++;
printk("0x%02x", c);
cnt++;
if (!(cnt % 16))
printk("\n");
else
printk(" ");
}
if (cnt % 16)
printk("\n");
}
/**************************************************************************
* ql1280_print_scsi_cmd
*
**************************************************************************/
static void
__qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
{
struct scsi_qla_host *ha;
struct Scsi_Host *host = CMD_HOST(cmd);
struct srb *sp;
/* struct scatterlist *sg; */
int i;
ha = (struct scsi_qla_host *)host->hostdata;
sp = (struct srb *)CMD_SP(cmd);
printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
CMD_CDBLEN(cmd));
printk(" CDB = ");
for (i = 0; i < cmd->cmd_len; i++) {
printk("0x%02x ", cmd->cmnd[i]);
}
printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
printk(" request buffer=0x%p, request buffer len=0x%x\n",
scsi_sglist(cmd), scsi_bufflen(cmd));
/* if (cmd->use_sg)
{
sg = (struct scatterlist *) cmd->request_buffer;
printk(" SG buffer: \n");
qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
} */
printk(" tag=%d, transfersize=0x%x \n",
scsi_cmd_to_rq(cmd)->tag, cmd->transfersize);
printk(" SP=0x%p\n", CMD_SP(cmd));
printk(" underflow size = 0x%x, direction=0x%x\n",
cmd->underflow, cmd->sc_data_direction);
}
/**************************************************************************
* ql1280_dump_device
*
**************************************************************************/
static void
ql1280_dump_device(struct scsi_qla_host *ha)
{
struct scsi_cmnd *cp;
struct srb *sp;
int i;
printk(KERN_DEBUG "Outstanding Commands on controller:\n");
for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
if ((sp = ha->outstanding_cmds[i]) == NULL)
continue;
if ((cp = sp->cmd) == NULL)
continue;
qla1280_print_scsi_cmd(1, cp);
}
}
#endif
enum tokens {
TOKEN_NVRAM,
TOKEN_SYNC,
TOKEN_WIDE,
TOKEN_PPR,
TOKEN_VERBOSE,
TOKEN_DEBUG,
};
struct setup_tokens {
char *token;
int val;
};
static struct setup_tokens setup_token[] __initdata =
{
{ "nvram", TOKEN_NVRAM },
{ "sync", TOKEN_SYNC },
{ "wide", TOKEN_WIDE },
{ "ppr", TOKEN_PPR },
{ "verbose", TOKEN_VERBOSE },
{ "debug", TOKEN_DEBUG },
};
/**************************************************************************
* qla1280_setup
*
* Handle boot parameters. This really needs to be changed so one
* can specify per adapter parameters.
**************************************************************************/
static int __init
qla1280_setup(char *s)
{
char *cp, *ptr;
unsigned long val;
int toke;
cp = s;
while (cp && (ptr = strchr(cp, ':'))) {
ptr++;
if (!strcmp(ptr, "yes")) {
val = 0x10000;
ptr += 3;
} else if (!strcmp(ptr, "no")) {
val = 0;
ptr += 2;
} else
val = simple_strtoul(ptr, &ptr, 0);
switch ((toke = qla1280_get_token(cp))) {
case TOKEN_NVRAM:
if (!val)
driver_setup.no_nvram = 1;
break;
case TOKEN_SYNC:
if (!val)
driver_setup.no_sync = 1;
else if (val != 0x10000)
driver_setup.sync_mask = val;
break;
case TOKEN_WIDE:
if (!val)
driver_setup.no_wide = 1;
else if (val != 0x10000)
driver_setup.wide_mask = val;
break;
case TOKEN_PPR:
if (!val)
driver_setup.no_ppr = 1;
else if (val != 0x10000)
driver_setup.ppr_mask = val;
break;
case TOKEN_VERBOSE:
qla1280_verbose = val;
break;
default:
printk(KERN_INFO "qla1280: unknown boot option %s\n",
cp);
}
cp = strchr(ptr, ';');
if (cp)
cp++;
else {
break;
}
}
return 1;
}
static int __init
qla1280_get_token(char *str)
{
char *sep;
long ret = -1;
int i;
sep = strchr(str, ':');
if (sep) {
for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
if (!strncmp(setup_token[i].token, str, (sep - str))) {
ret = setup_token[i].val;
break;
}
}
}
return ret;
}
static struct scsi_host_template qla1280_driver_template = {
.module = THIS_MODULE,
.proc_name = "qla1280",
.name = "Qlogic ISP 1280/12160",
.info = qla1280_info,
.slave_configure = qla1280_slave_configure,
.queuecommand = qla1280_queuecommand,
.eh_abort_handler = qla1280_eh_abort,
.eh_device_reset_handler= qla1280_eh_device_reset,
.eh_bus_reset_handler = qla1280_eh_bus_reset,
.eh_host_reset_handler = qla1280_eh_adapter_reset,
.bios_param = qla1280_biosparam,
.can_queue = MAX_OUTSTANDING_COMMANDS,
.this_id = -1,
.sg_tablesize = SG_ALL,
};
static int
qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
{
int devnum = id->driver_data;
struct qla_boards *bdp = &ql1280_board_tbl[devnum];
struct Scsi_Host *host;
struct scsi_qla_host *ha;
int error = -ENODEV;
/* Bypass all AMI SUBSYS VENDOR IDs */
if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
printk(KERN_INFO
"qla1280: Skipping AMI SubSys Vendor ID Chip\n");
goto error;
}
printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
if (pci_enable_device(pdev)) {
printk(KERN_WARNING
"qla1280: Failed to enabled pci device, aborting.\n");
goto error;
}
pci_set_master(pdev);
error = -ENOMEM;
host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
if (!host) {
printk(KERN_WARNING
"qla1280: Failed to register host, aborting.\n");
goto error_disable_device;
}
ha = (struct scsi_qla_host *)host->hostdata;
memset(ha, 0, sizeof(struct scsi_qla_host));
ha->pdev = pdev;
ha->devnum = devnum; /* specifies microcode load address */
#ifdef QLA_64BIT_PTR
if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV;
goto error_put_host;
}
} else
dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
ha->host_no);
#else
if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
printk(KERN_WARNING "scsi(%li): Unable to set a "
"suitable DMA mask - aborting\n", ha->host_no);
error = -ENODEV;
goto error_put_host;
}
#endif
ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
&ha->request_dma, GFP_KERNEL);
if (!ha->request_ring) {
printk(KERN_INFO "qla1280: Failed to get request memory\n");
goto error_put_host;
}
ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
&ha->response_dma, GFP_KERNEL);
if (!ha->response_ring) {
printk(KERN_INFO "qla1280: Failed to get response memory\n");
goto error_free_request_ring;
}
ha->ports = bdp->numPorts;
ha->host = host;
ha->host_no = host->host_no;
host->irq = pdev->irq;
host->max_channel = bdp->numPorts - 1;
host->max_lun = MAX_LUNS - 1;
host->max_id = MAX_TARGETS;
host->max_sectors = 1024;
host->unique_id = host->host_no;
error = -ENODEV;
#if MEMORY_MAPPED_IO
ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
if (!ha->mmpbase) {
printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
goto error_free_response_ring;
}
host->base = (unsigned long)ha->mmpbase;
ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
#else
host->io_port = pci_resource_start(ha->pdev, 0);
if (!request_region(host->io_port, 0xff, "qla1280")) {
printk(KERN_INFO "qla1280: Failed to reserve i/o region "
"0x%04lx-0x%04lx - already in use\n",
host->io_port, host->io_port + 0xff);
goto error_free_response_ring;
}
ha->iobase = (struct device_reg *)host->io_port;
#endif
INIT_LIST_HEAD(&ha->done_q);
/* Disable ISP interrupts. */
qla1280_disable_intrs(ha);
if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
"qla1280", ha)) {
printk("qla1280 : Failed to reserve interrupt %d already "
"in use\n", pdev->irq);
goto error_release_region;
}
/* load the F/W, read paramaters, and init the H/W */
if (qla1280_initialize_adapter(ha)) {
printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
goto error_free_irq;
}
/* set our host ID (need to do something about our two IDs) */
host->this_id = ha->bus_settings[0].id;
pci_set_drvdata(pdev, host);
error = scsi_add_host(host, &pdev->dev);
if (error)
goto error_disable_adapter;
scsi_scan_host(host);
return 0;
error_disable_adapter:
qla1280_disable_intrs(ha);
error_free_irq:
free_irq(pdev->irq, ha);
error_release_region:
#if MEMORY_MAPPED_IO
iounmap(ha->mmpbase);
#else
release_region(host->io_port, 0xff);
#endif
error_free_response_ring:
dma_free_coherent(&ha->pdev->dev,
((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
ha->response_ring, ha->response_dma);
error_free_request_ring:
dma_free_coherent(&ha->pdev->dev,
((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
ha->request_ring, ha->request_dma);
error_put_host:
scsi_host_put(host);
error_disable_device:
pci_disable_device(pdev);
error:
return error;
}
static void
qla1280_remove_one(struct pci_dev *pdev)
{
struct Scsi_Host *host = pci_get_drvdata(pdev);
struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
scsi_remove_host(host);
qla1280_disable_intrs(ha);
free_irq(pdev->irq, ha);
#if MEMORY_MAPPED_IO
iounmap(ha->mmpbase);
#else
release_region(host->io_port, 0xff);
#endif
dma_free_coherent(&ha->pdev->dev,
((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
ha->request_ring, ha->request_dma);
dma_free_coherent(&ha->pdev->dev,
((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
ha->response_ring, ha->response_dma);
pci_disable_device(pdev);
scsi_host_put(host);
}
static struct pci_driver qla1280_pci_driver = {
.name = "qla1280",
.id_table = qla1280_pci_tbl,
.probe = qla1280_probe_one,
.remove = qla1280_remove_one,
};
static int __init
qla1280_init(void)
{
if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
printk(KERN_WARNING
"qla1280: struct srb too big, aborting\n");
return -EINVAL;
}
#ifdef MODULE
/*
* If we are called as a module, the qla1280 pointer may not be null
* and it would point to our bootup string, just like on the lilo
* command line. IF not NULL, then process this config string with
* qla1280_setup
*
* Boot time Options
* To add options at boot time add a line to your lilo.conf file like:
* append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
* which will result in the first four devices on the first two
* controllers being set to a tagged queue depth of 32.
*/
if (qla1280)
qla1280_setup(qla1280);
#endif
return pci_register_driver(&qla1280_pci_driver);
}
static void __exit
qla1280_exit(void)
{
int i;
pci_unregister_driver(&qla1280_pci_driver);
/* release any allocated firmware images */
for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
release_firmware(qla1280_fw_tbl[i].fw);
qla1280_fw_tbl[i].fw = NULL;
}
}
module_init(qla1280_init);
module_exit(qla1280_exit);
MODULE_AUTHOR("Qlogic & Jes Sorensen");
MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
MODULE_LICENSE("GPL");
MODULE_FIRMWARE("qlogic/1040.bin");
MODULE_FIRMWARE("qlogic/1280.bin");
MODULE_FIRMWARE("qlogic/12160.bin");
MODULE_VERSION(QLA1280_VERSION);