Quelle  qla1280.c   Sprache: C

// 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


#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 const 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)
{
 struct Scsi_Host *host = cmd->device->host;
 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
 struct srb *sp = scsi_cmd_priv(cmd);
 int status;

 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,
};


static void qla1280_mailbox_timeout(struct timer_list *t)
{
 struct scsi_qla_host *ha = timer_container_of(ha, t, mailbox_timer);
 struct device_reg __iomem *reg;
 reg = ha->iobase;

 ha->mailbox_out[0] = RD_REG_WORD(®->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(®->ictrl), RD_REG_WORD(®->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;
  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 = scsi_cmd_priv(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;

 default:
  dprintk(1, "RESET invalid action %d\n", action);
  return FAILED;
 }

 /*
 * 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 = SUCCESS;
 struct Scsi_Host *shost = cmd->device->host;
 struct scsi_qla_host *ha = (struct scsi_qla_host *)shost->hostdata;

 spin_lock_irq(shost->host_lock);
 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 */
  rc = FAILED;
 }

 ha->flags.reset_active = 0;

 spin_unlock_irq(shost->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(®->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_sdev_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_sdev_configure(struct scsi_device *device, struct queue_limits *lim)
{
 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)
   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(®->semaphore, 0);
 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
 RD_REG_WORD(®->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", ®->id_l);

 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);

 /* Soft reset chip and wait for it to finish. */
 WRT_REG_WORD(®->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(®->ictrl);
 /*
 * Yet another QLogic gem ;-(
 */
 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
  udelay(5);
  data = RD_REG_WORD(®->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(®->cfg_1, 0);

 /* Reset RISC and disable BIOS which
   allows RISC to execute out of RAM. */
 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
       HC_RELEASE_RISC | HC_DISABLE_BIOS);

 RD_REG_WORD(®->id_l); /* Flush PCI write */
 data = qla1280_debounce_register(®->mailbox0);

 /*
 * I *LOVE* this code!
 */
 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
  udelay(5);
  data = RD_REG_WORD(®->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(®->mailbox1) != PROD_ID_1 ||
     (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
      RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
     RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
     RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
  printk(KERN_INFO "qla1280: Wrong product ID = "
         "0x%x,0x%x,0x%x,0x%x\n",
         RD_REG_WORD(®->mailbox1),
         RD_REG_WORD(®->mailbox2),
         RD_REG_WORD(®->mailbox3),
         RD_REG_WORD(®->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. */
--> --------------------

--> maximum size reached

--> --------------------