4390 lines · c
1// SPDX-License-Identifier: GPL-2.0-or-later2/******************************************************************************3* QLOGIC LINUX SOFTWARE4*5* QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver6* Copyright (C) 2000 Qlogic Corporation (www.qlogic.com)7* Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc.8* Copyright (C) 2003-2004 Christoph Hellwig9*10******************************************************************************/11#define QLA1280_VERSION "3.27.1"12/*****************************************************************************13 Revision History:14 Rev 3.27.1, February 8, 2010, Michael Reed15 - Retain firmware image for error recovery.16 Rev 3.27, February 10, 2009, Michael Reed17 - General code cleanup.18 - Improve error recovery.19 Rev 3.26, January 16, 2006 Jes Sorensen20 - Ditch all < 2.6 support21 Rev 3.25.1, February 10, 2005 Christoph Hellwig22 - use pci_map_single to map non-S/G requests23 - remove qla1280_proc_info24 Rev 3.25, September 28, 2004, Christoph Hellwig25 - add support for ISP1020/104026 - don't include "scsi.h" anymore for 2.6.x27 Rev 3.24.4 June 7, 2004 Christoph Hellwig28 - restructure firmware loading, cleanup initialization code29 - prepare support for ISP1020/1040 chips30 Rev 3.24.3 January 19, 2004, Jes Sorensen31 - Handle PCI DMA mask settings correctly32 - Correct order of error handling in probe_one, free_irq should not33 be called if request_irq failed34 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez35 - Big endian fixes (James)36 - Remove bogus IOCB content on zero data transfer commands (Andrew)37 Rev 3.24.1 January 5, 2004, Jes Sorensen38 - Initialize completion queue to avoid OOPS on probe39 - Handle interrupts during mailbox testing40 Rev 3.24 November 17, 2003, Christoph Hellwig41 - use struct list_head for completion queue42 - avoid old Scsi_FOO typedefs43 - cleanup 2.4 compat glue a bit44 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"45 - make initialization for memory mapped vs port I/O more similar46 - remove broken pci config space manipulation47 - kill more cruft48 - this is an almost perfect 2.6 scsi driver now! ;)49 Rev 3.23.39 December 17, 2003, Jes Sorensen50 - Delete completion queue from srb if mailbox command failed to51 to avoid qla1280_done completeting qla1280_error_action's52 obsolete context53 - Reduce arguments for qla1280_done54 Rev 3.23.38 October 18, 2003, Christoph Hellwig55 - Convert to new-style hotplugable driver for 2.656 - Fix missing scsi_unregister/scsi_host_put on HBA removal57 - Kill some more cruft58 Rev 3.23.37 October 1, 2003, Jes Sorensen59 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another60 random CONFIG option61 - Clean up locking in probe path62 Rev 3.23.36 October 1, 2003, Christoph Hellwig63 - queuecommand only ever receives new commands - clear flags64 - Reintegrate lost fixes from Linux 2.565 Rev 3.23.35 August 14, 2003, Jes Sorensen66 - Build against 2.667 Rev 3.23.34 July 23, 2003, Jes Sorensen68 - Remove pointless TRUE/FALSE macros69 - Clean up vchan handling70 Rev 3.23.33 July 3, 2003, Jes Sorensen71 - Don't define register access macros before define determining MMIO.72 This just happened to work out on ia64 but not elsewhere.73 - Don't try and read from the card while it is in reset as74 it won't respond and causes an MCA75 Rev 3.23.32 June 23, 2003, Jes Sorensen76 - Basic support for boot time arguments77 Rev 3.23.31 June 8, 2003, Jes Sorensen78 - Reduce boot time messages79 Rev 3.23.30 June 6, 2003, Jes Sorensen80 - Do not enable sync/wide/ppr before it has been determined81 that the target device actually supports it82 - Enable DMA arbitration for multi channel controllers83 Rev 3.23.29 June 3, 2003, Jes Sorensen84 - Port to 2.5.6985 Rev 3.23.28 June 3, 2003, Jes Sorensen86 - Eliminate duplicate marker commands on bus resets87 - Handle outstanding commands appropriately on bus/device resets88 Rev 3.23.27 May 28, 2003, Jes Sorensen89 - Remove bogus input queue code, let the Linux SCSI layer do the work90 - Clean up NVRAM handling, only read it once from the card91 - Add a number of missing default nvram parameters92 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen93 - Use completion queue for mailbox commands instead of busy wait94 Rev 3.23.25 Beta May 27, 2003, James Bottomley95 - Migrate to use new error handling code96 Rev 3.23.24 Beta May 21, 2003, James Bottomley97 - Big endian support98 - Cleanup data direction code99 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen100 - Switch to using MMIO instead of PIO101 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen102 - Fix PCI parity problem with 12160 during reset.103 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen104 - Use pci_map_page()/pci_unmap_page() instead of map_single version.105 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen106 - Remove < 2.4.x support107 - Introduce HOST_LOCK to make the spin lock changes portable.108 - Remove a bunch of idiotic and unnecessary typedef's109 - Kill all leftovers of target-mode support which never worked anyway110 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds111 - Do qla1280_pci_config() before calling request_irq() and112 request_region()113 - Use pci_dma_hi32() to handle upper word of DMA addresses instead114 of large shifts115 - Hand correct arguments to free_irq() in case of failure116 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen117 - Run source through Lindent and clean up the output118 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen119 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32120 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen121 - Rely on mailbox commands generating interrupts - do not122 run qla1280_isr() from ql1280_mailbox_command()123 - Remove device_reg_t124 - Integrate ql12160_set_target_parameters() with 1280 version125 - Make qla1280_setup() non static126 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request127 sent to the card - this command pauses the firmware!!!128 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen129 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions130 - Remove a pile of pointless and confusing (srb_t **) and131 (scsi_lu_t *) typecasts132 - Explicit mark that we do not use the new error handling (for now)133 - Remove scsi_qla_host_t and use 'struct' instead134 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,135 pci_64bit_slot flags which weren't used for anything anyway136 - Grab host->host_lock while calling qla1280_isr() from abort()137 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we138 do not need to save/restore flags in the interrupt handler139 - Enable interrupts early (before any mailbox access) in preparation140 for cleaning up the mailbox handling141 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen142 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace143 it with proper use of dprintk().144 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take145 a debug level argument to determine if data is to be printed146 - Add KERN_* info to printk()147 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen148 - Significant cosmetic cleanups149 - Change debug code to use dprintk() and remove #if mess150 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen151 - More cosmetic cleanups, fix places treating return as function152 - use cpu_relax() in qla1280_debounce_register()153 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen154 - Make it compile under 2.5.5155 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen156 - Do no typecast short * to long * in QL1280BoardTbl, this157 broke miserably on big endian boxes158 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen159 - Remove pre 2.2 hack for checking for reentrance in interrupt handler160 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32161 unsigned int to match the types from struct scsi_cmnd162 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen163 - Remove bogus timer_t typedef from qla1280.h164 - Remove obsolete pre 2.2 PCI setup code, use proper #define's165 for PCI_ values, call pci_set_master()166 - Fix memleak of qla1280_buffer on module unload167 - Only compile module parsing code #ifdef MODULE - should be168 changed to use individual MODULE_PARM's later169 - Remove dummy_buffer that was never modified nor printed170 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove171 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls172 - Remove \r from print statements, this is Linux, not DOS173 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}174 dummy macros175 - Remove C++ compile hack in header file as Linux driver are not176 supposed to be compiled as C++177 - Kill MS_64BITS macro as it makes the code more readable178 - Remove unnecessary flags.in_interrupts bit179 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen180 - Dont' check for set flags on q->q_flag one by one in qla1280_next()181 - Check whether the interrupt was generated by the QLA1280 before182 doing any processing183 - qla1280_status_entry(): Only zero out part of sense_buffer that184 is not being copied into185 - Remove more superflouous typecasts186 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()187 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel188 - Don't walk the entire list in qla1280_putq_t() just to directly189 grab the pointer to the last element afterwards190 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen191 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver192 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen193 - Set dev->max_sectors to 1024194 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen195 - Provide compat macros for pci_enable_device(), pci_find_subsys()196 and scsi_set_pci_device()197 - Call scsi_set_pci_device() for all devices198 - Reduce size of kernel version dependent device probe code199 - Move duplicate probe/init code to separate function200 - Handle error if qla1280_mem_alloc() fails201 - Kill OFFSET() macro and use Linux's PCI definitions instead202 - Kill private structure defining PCI config space (struct config_reg)203 - Only allocate I/O port region if not in MMIO mode204 - Remove duplicate (unused) sanity check of sife of srb_t205 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen206 - Change home-brew memset() implementations to use memset()207 - Remove all references to COMTRACE() - accessing a PC's COM2 serial208 port directly is not legal under Linux.209 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen210 - Remove pre 2.2 kernel support211 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)212 - Fix MMIO access to use readl/writel instead of directly213 dereferencing pointers214 - Nuke MSDOS debugging code215 - Change true/false data types to int from uint8_t216 - Use int for counters instead of uint8_t etc.217 - Clean up size & byte order conversion macro usage218 Rev 3.23 Beta January 11, 2001 BN Qlogic219 - Added check of device_id when handling non220 QLA12160s during detect().221 Rev 3.22 Beta January 5, 2001 BN Qlogic222 - Changed queue_task() to schedule_task()223 for kernels 2.4.0 and higher.224 Note: 2.4.0-testxx kernels released prior to225 the actual 2.4.0 kernel release on January 2001226 will get compile/link errors with schedule_task().227 Please update your kernel to released 2.4.0 level,228 or comment lines in this file flagged with 3.22229 to resolve compile/link error of schedule_task().230 - Added -DCONFIG_SMP in addition to -D__SMP__231 in Makefile for 2.4.0 builds of driver as module.232 Rev 3.21 Beta January 4, 2001 BN Qlogic233 - Changed criteria of 64/32 Bit mode of HBA234 operation according to BITS_PER_LONG rather235 than HBA's NVRAM setting of >4Gig memory bit;236 so that the HBA auto-configures without the need237 to setup each system individually.238 Rev 3.20 Beta December 5, 2000 BN Qlogic239 - Added priority handling to IA-64 onboard SCSI240 ISP12160 chip for kernels greater than 2.3.18.241 - Added irqrestore for qla1280_intr_handler.242 - Enabled /proc/scsi/qla1280 interface.243 - Clear /proc/scsi/qla1280 counters in detect().244 Rev 3.19 Beta October 13, 2000 BN Qlogic245 - Declare driver_template for new kernel246 (2.4.0 and greater) scsi initialization scheme.247 - Update /proc/scsi entry for 2.3.18 kernels and248 above as qla1280249 Rev 3.18 Beta October 10, 2000 BN Qlogic250 - Changed scan order of adapters to map251 the QLA12160 followed by the QLA1280.252 Rev 3.17 Beta September 18, 2000 BN Qlogic253 - Removed warnings for 32 bit 2.4.x compiles254 - Corrected declared size for request and response255 DMA addresses that are kept in each ha256 Rev. 3.16 Beta August 25, 2000 BN Qlogic257 - Corrected 64 bit addressing issue on IA-64258 where the upper 32 bits were not properly259 passed to the RISC engine.260 Rev. 3.15 Beta August 22, 2000 BN Qlogic261 - Modified qla1280_setup_chip to properly load262 ISP firmware for greater that 4 Gig memory on IA-64263 Rev. 3.14 Beta August 16, 2000 BN Qlogic264 - Added setting of dma_mask to full 64 bit265 if flags.enable_64bit_addressing is set in NVRAM266 Rev. 3.13 Beta August 16, 2000 BN Qlogic267 - Use new PCI DMA mapping APIs for 2.4.x kernel268 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic269 - Added check of pci_enable_device to detect() for 2.3.x270 - Use pci_resource_start() instead of271 pdev->resource[0].start in detect() for 2.3.x272 - Updated driver version273 Rev. 3.11 July 14, 2000 BN Qlogic274 - Updated SCSI Firmware to following versions:275 qla1x80: 8.13.08276 qla1x160: 10.04.08277 - Updated driver version to 3.11278 Rev. 3.10 June 23, 2000 BN Qlogic279 - Added filtering of AMI SubSys Vendor ID devices280 Rev. 3.9281 - DEBUG_QLA1280 undefined and new version BN Qlogic282 Rev. 3.08b May 9, 2000 MD Dell283 - Added logic to check against AMI subsystem vendor ID284 Rev. 3.08 May 4, 2000 DG Qlogic285 - Added logic to check for PCI subsystem ID.286 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic287 - Updated SCSI Firmware to following versions:288 qla12160: 10.01.19289 qla1280: 8.09.00290 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic291 - Internal revision; not released292 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic293 - Edit correction for virt_to_bus and PROC.294 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic295 - Merge changes from ia64 port.296 Rev. 3.03 Mar 28, 2000 BN Qlogic297 - Increase version to reflect new code drop with compile fix298 of issue with inclusion of linux/spinlock for 2.3 kernels299 Rev. 3.02 Mar 15, 2000 BN Qlogic300 - Merge qla1280_proc_info from 2.10 code base301 Rev. 3.01 Feb 10, 2000 BN Qlogic302 - Corrected code to compile on a 2.2.x kernel.303 Rev. 3.00 Jan 17, 2000 DG Qlogic304 - Added 64-bit support.305 Rev. 2.07 Nov 9, 1999 DG Qlogic306 - Added new routine to set target parameters for ISP12160.307 Rev. 2.06 Sept 10, 1999 DG Qlogic308 - Added support for ISP12160 Ultra 3 chip.309 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont310 - Modified code to remove errors generated when compiling with311 Cygnus IA64 Compiler.312 - Changed conversion of pointers to unsigned longs instead of integers.313 - Changed type of I/O port variables from uint32_t to unsigned long.314 - Modified OFFSET macro to work with 64-bit as well as 32-bit.315 - Changed sprintf and printk format specifiers for pointers to %p.316 - Changed some int to long type casts where needed in sprintf & printk.317 - Added l modifiers to sprintf and printk format specifiers for longs.318 - Removed unused local variables.319 Rev. 1.20 June 8, 1999 DG, Qlogic320 Changes to support RedHat release 6.0 (kernel 2.2.5).321 - Added SCSI exclusive access lock (io_request_lock) when accessing322 the adapter.323 - Added changes for the new LINUX interface template. Some new error324 handling routines have been added to the template, but for now we325 will use the old ones.326 - Initial Beta Release.327*****************************************************************************/328 329 330#include <linux/module.h>331 332#include <linux/types.h>333#include <linux/string.h>334#include <linux/errno.h>335#include <linux/kernel.h>336#include <linux/ioport.h>337#include <linux/delay.h>338#include <linux/timer.h>339#include <linux/pci.h>340#include <linux/proc_fs.h>341#include <linux/stat.h>342#include <linux/pci_ids.h>343#include <linux/interrupt.h>344#include <linux/init.h>345#include <linux/dma-mapping.h>346#include <linux/firmware.h>347 348#include <asm/io.h>349#include <asm/irq.h>350#include <asm/byteorder.h>351#include <asm/processor.h>352#include <asm/types.h>353 354#include <scsi/scsi.h>355#include <scsi/scsi_cmnd.h>356#include <scsi/scsi_device.h>357#include <scsi/scsi_host.h>358#include <scsi/scsi_tcq.h>359 360 361/*362 * Compile time Options:363 * 0 - Disable and 1 - Enable364 */365#define DEBUG_QLA1280_INTR 0366#define DEBUG_PRINT_NVRAM 0367#define DEBUG_QLA1280 0368 369#define MEMORY_MAPPED_IO 1370 371#include "qla1280.h"372 373#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT374#define QLA_64BIT_PTR 1375#endif376 377#define NVRAM_DELAY() udelay(500) /* 2 microseconds */378 379#define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)380#define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \381 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)382#define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \383 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)384 385 386static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);387static void qla1280_remove_one(struct pci_dev *);388 389/*390 * QLogic Driver Support Function Prototypes.391 */392static void qla1280_done(struct scsi_qla_host *);393static int qla1280_get_token(char *);394static int qla1280_setup(char *s) __init;395 396/*397 * QLogic ISP1280 Hardware Support Function Prototypes.398 */399static int qla1280_load_firmware(struct scsi_qla_host *);400static int qla1280_init_rings(struct scsi_qla_host *);401static int qla1280_nvram_config(struct scsi_qla_host *);402static int qla1280_mailbox_command(struct scsi_qla_host *,403 uint8_t, uint16_t *);404static int qla1280_bus_reset(struct scsi_qla_host *, int);405static int qla1280_device_reset(struct scsi_qla_host *, int, int);406static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);407static int qla1280_abort_isp(struct scsi_qla_host *);408#ifdef QLA_64BIT_PTR409static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);410#else411static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);412#endif413static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);414static void qla1280_poll(struct scsi_qla_host *);415static void qla1280_reset_adapter(struct scsi_qla_host *);416static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);417static void qla1280_isp_cmd(struct scsi_qla_host *);418static void qla1280_isr(struct scsi_qla_host *, struct list_head *);419static void qla1280_rst_aen(struct scsi_qla_host *);420static void qla1280_status_entry(struct scsi_qla_host *, struct response *,421 struct list_head *);422static void qla1280_error_entry(struct scsi_qla_host *, struct response *,423 struct list_head *);424static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);425static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);426static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);427static request_t *qla1280_req_pkt(struct scsi_qla_host *);428static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,429 unsigned int);430static void qla1280_get_target_parameters(struct scsi_qla_host *,431 struct scsi_device *);432static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);433 434 435static struct qla_driver_setup driver_setup;436 437/*438 * convert scsi data direction to request_t control flags439 */440static inline uint16_t441qla1280_data_direction(struct scsi_cmnd *cmnd)442{443 switch(cmnd->sc_data_direction) {444 case DMA_FROM_DEVICE:445 return BIT_5;446 case DMA_TO_DEVICE:447 return BIT_6;448 case DMA_BIDIRECTIONAL:449 return BIT_5 | BIT_6;450 /*451 * We could BUG() on default here if one of the four cases aren't452 * met, but then again if we receive something like that from the453 * SCSI layer we have more serious problems. This shuts up GCC.454 */455 case DMA_NONE:456 default:457 return 0;458 }459}460 461#if DEBUG_QLA1280462static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);463static void __qla1280_dump_buffer(char *, int);464#endif465 466 467/*468 * insmod needs to find the variable and make it point to something469 */470#ifdef MODULE471static char *qla1280;472 473/* insmod qla1280 options=verbose" */474module_param(qla1280, charp, 0);475#else476__setup("qla1280=", qla1280_setup);477#endif478 479 480#define CMD_CDBLEN(Cmnd) Cmnd->cmd_len481#define CMD_CDBP(Cmnd) Cmnd->cmnd482#define CMD_SNSP(Cmnd) Cmnd->sense_buffer483#define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE484#define CMD_RESULT(Cmnd) Cmnd->result485#define CMD_HANDLE(Cmnd) Cmnd->host_scribble486 487#define CMD_HOST(Cmnd) Cmnd->device->host488#define SCSI_BUS_32(Cmnd) Cmnd->device->channel489#define SCSI_TCN_32(Cmnd) Cmnd->device->id490#define SCSI_LUN_32(Cmnd) Cmnd->device->lun491 492 493/*****************************************/494/* ISP Boards supported by this driver */495/*****************************************/496 497struct qla_boards {498 char *name; /* Board ID String */499 int numPorts; /* Number of SCSI ports */500 int fw_index; /* index into qla1280_fw_tbl for firmware */501};502 503/* NOTE: the last argument in each entry is used to index ql1280_board_tbl */504static struct pci_device_id qla1280_pci_tbl[] = {505 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,506 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},507 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,508 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},509 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,510 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},511 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,512 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},513 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,514 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},515 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,516 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},517 {0,}518};519MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);520 521static DEFINE_MUTEX(qla1280_firmware_mutex);522 523struct qla_fw {524 char *fwname;525 const struct firmware *fw;526};527 528#define QL_NUM_FW_IMAGES 3529 530static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {531 {"qlogic/1040.bin", NULL}, /* image 0 */532 {"qlogic/1280.bin", NULL}, /* image 1 */533 {"qlogic/12160.bin", NULL}, /* image 2 */534};535 536/* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */537static struct qla_boards ql1280_board_tbl[] = {538 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},539 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},540 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},541 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},542 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},543 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},544 {.name = " ", .numPorts = 0, .fw_index = -1},545};546 547static int qla1280_verbose = 1;548 549#if DEBUG_QLA1280550static int ql_debug_level = 1;551#define dprintk(level, format, a...) \552 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)553#define qla1280_dump_buffer(level, buf, size) \554 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)555#define qla1280_print_scsi_cmd(level, cmd) \556 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)557#else558#define ql_debug_level 0559#define dprintk(level, format, a...) do{}while(0)560#define qla1280_dump_buffer(a, b, c) do{}while(0)561#define qla1280_print_scsi_cmd(a, b) do{}while(0)562#endif563 564#define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);565#define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);566#define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);567#define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);568 569 570static int qla1280_read_nvram(struct scsi_qla_host *ha)571{572 uint16_t *wptr;573 uint8_t chksum;574 int cnt, i;575 struct nvram *nv;576 577 ENTER("qla1280_read_nvram");578 579 if (driver_setup.no_nvram)580 return 1;581 582 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);583 584 wptr = (uint16_t *)&ha->nvram;585 nv = &ha->nvram;586 chksum = 0;587 for (cnt = 0; cnt < 3; cnt++) {588 *wptr = qla1280_get_nvram_word(ha, cnt);589 chksum += *wptr & 0xff;590 chksum += (*wptr >> 8) & 0xff;591 wptr++;592 }593 594 if (nv->id0 != 'I' || nv->id1 != 'S' ||595 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {596 dprintk(2, "Invalid nvram ID or version!\n");597 chksum = 1;598 } else {599 for (; cnt < sizeof(struct nvram); cnt++) {600 *wptr = qla1280_get_nvram_word(ha, cnt);601 chksum += *wptr & 0xff;602 chksum += (*wptr >> 8) & 0xff;603 wptr++;604 }605 }606 607 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"608 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,609 nv->version);610 611 612 if (chksum) {613 if (!driver_setup.no_nvram)614 printk(KERN_WARNING "scsi(%ld): Unable to identify or "615 "validate NVRAM checksum, using default "616 "settings\n", ha->host_no);617 ha->nvram_valid = 0;618 } else619 ha->nvram_valid = 1;620 621 /* The firmware interface is, um, interesting, in that the622 * actual firmware image on the chip is little endian, thus,623 * the process of taking that image to the CPU would end up624 * little endian. However, the firmware interface requires it625 * to be read a word (two bytes) at a time.626 *627 * The net result of this would be that the word (and628 * doubleword) quantities in the firmware would be correct, but629 * the bytes would be pairwise reversed. Since most of the630 * firmware quantities are, in fact, bytes, we do an extra631 * le16_to_cpu() in the firmware read routine.632 *633 * The upshot of all this is that the bytes in the firmware634 * are in the correct places, but the 16 and 32 bit quantities635 * are still in little endian format. We fix that up below by636 * doing extra reverses on them */637 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);638 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);639 for(i = 0; i < MAX_BUSES; i++) {640 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);641 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);642 }643 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");644 LEAVE("qla1280_read_nvram");645 646 return chksum;647}648 649/**************************************************************************650 * qla1280_info651 * Return a string describing the driver.652 **************************************************************************/653static const char *654qla1280_info(struct Scsi_Host *host)655{656 static char qla1280_scsi_name_buffer[125];657 char *bp;658 struct scsi_qla_host *ha;659 struct qla_boards *bdp;660 661 bp = &qla1280_scsi_name_buffer[0];662 ha = (struct scsi_qla_host *)host->hostdata;663 bdp = &ql1280_board_tbl[ha->devnum];664 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));665 666 sprintf (bp,667 "QLogic %s PCI to SCSI Host Adapter\n"668 " Firmware version: %2d.%02d.%02d, Driver version %s",669 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,670 QLA1280_VERSION);671 return bp;672}673 674/**************************************************************************675 * qla1280_queuecommand676 * Queue a command to the controller.677 *678 * Note:679 * The mid-level driver tries to ensures that queuecommand never gets invoked680 * concurrently with itself or the interrupt handler (although the681 * interrupt handler may call this routine as part of request-completion682 * handling). Unfortunately, it sometimes calls the scheduler in interrupt683 * context which is a big NO! NO!.684 **************************************************************************/685static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd)686{687 struct Scsi_Host *host = cmd->device->host;688 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;689 struct srb *sp = scsi_cmd_priv(cmd);690 int status;691 692 sp->cmd = cmd;693 sp->flags = 0;694 sp->wait = NULL;695 CMD_HANDLE(cmd) = (unsigned char *)NULL;696 697 qla1280_print_scsi_cmd(5, cmd);698 699#ifdef QLA_64BIT_PTR700 /*701 * Using 64 bit commands if the PCI bridge doesn't support it is a702 * bit wasteful, however this should really only happen if one's703 * PCI controller is completely broken, like the BCM1250. For704 * sane hardware this is not an issue.705 */706 status = qla1280_64bit_start_scsi(ha, sp);707#else708 status = qla1280_32bit_start_scsi(ha, sp);709#endif710 return status;711}712 713static DEF_SCSI_QCMD(qla1280_queuecommand)714 715enum action {716 ABORT_COMMAND,717 DEVICE_RESET,718 BUS_RESET,719};720 721 722static void qla1280_mailbox_timeout(struct timer_list *t)723{724 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);725 struct device_reg __iomem *reg;726 reg = ha->iobase;727 728 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);729 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "730 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],731 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));732 complete(ha->mailbox_wait);733}734 735static int736_qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,737 struct completion *wait)738{739 int status = FAILED;740 struct scsi_cmnd *cmd = sp->cmd;741 742 spin_unlock_irq(ha->host->host_lock);743 wait_for_completion_timeout(wait, 4*HZ);744 spin_lock_irq(ha->host->host_lock);745 sp->wait = NULL;746 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {747 status = SUCCESS;748 scsi_done(cmd);749 }750 return status;751}752 753static int754qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)755{756 DECLARE_COMPLETION_ONSTACK(wait);757 758 sp->wait = &wait;759 return _qla1280_wait_for_single_command(ha, sp, &wait);760}761 762static int763qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)764{765 int cnt;766 int status;767 struct srb *sp;768 struct scsi_cmnd *cmd;769 770 status = SUCCESS;771 772 /*773 * Wait for all commands with the designated bus/target774 * to be completed by the firmware775 */776 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {777 sp = ha->outstanding_cmds[cnt];778 if (sp) {779 cmd = sp->cmd;780 781 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)782 continue;783 if (target >= 0 && SCSI_TCN_32(cmd) != target)784 continue;785 786 status = qla1280_wait_for_single_command(ha, sp);787 if (status == FAILED)788 break;789 }790 }791 return status;792}793 794/**************************************************************************795 * qla1280_error_action796 * The function will attempt to perform a specified error action and797 * wait for the results (or time out).798 *799 * Input:800 * cmd = Linux SCSI command packet of the command that cause the801 * bus reset.802 * action = error action to take (see action_t)803 *804 * Returns:805 * SUCCESS or FAILED806 *807 **************************************************************************/808static int809qla1280_error_action(struct scsi_cmnd *cmd, enum action action)810{811 struct scsi_qla_host *ha;812 int bus, target, lun;813 struct srb *sp;814 int i, found;815 int result=FAILED;816 int wait_for_bus=-1;817 int wait_for_target = -1;818 DECLARE_COMPLETION_ONSTACK(wait);819 820 ENTER("qla1280_error_action");821 822 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);823 sp = scsi_cmd_priv(cmd);824 bus = SCSI_BUS_32(cmd);825 target = SCSI_TCN_32(cmd);826 lun = SCSI_LUN_32(cmd);827 828 dprintk(4, "error_action %i, istatus 0x%04x\n", action,829 RD_REG_WORD(&ha->iobase->istatus));830 831 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",832 RD_REG_WORD(&ha->iobase->host_cmd),833 RD_REG_WORD(&ha->iobase->ictrl), jiffies);834 835 if (qla1280_verbose)836 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "837 "Handle=0x%p, action=0x%x\n",838 ha->host_no, cmd, CMD_HANDLE(cmd), action);839 840 /*841 * Check to see if we have the command in the outstanding_cmds[]842 * array. If not then it must have completed before this error843 * action was initiated. If the error_action isn't ABORT_COMMAND844 * then the driver must proceed with the requested action.845 */846 found = -1;847 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {848 if (sp == ha->outstanding_cmds[i]) {849 found = i;850 sp->wait = &wait; /* we'll wait for it to complete */851 break;852 }853 }854 855 if (found < 0) { /* driver doesn't have command */856 result = SUCCESS;857 if (qla1280_verbose) {858 printk(KERN_INFO859 "scsi(%ld:%d:%d:%d): specified command has "860 "already completed.\n", ha->host_no, bus,861 target, lun);862 }863 }864 865 switch (action) {866 867 case ABORT_COMMAND:868 dprintk(1, "qla1280: RISC aborting command\n");869 /*870 * The abort might fail due to race when the host_lock871 * is released to issue the abort. As such, we872 * don't bother to check the return status.873 */874 if (found >= 0)875 qla1280_abort_command(ha, sp, found);876 break;877 878 case DEVICE_RESET:879 if (qla1280_verbose)880 printk(KERN_INFO881 "scsi(%ld:%d:%d:%d): Queueing device reset "882 "command.\n", ha->host_no, bus, target, lun);883 if (qla1280_device_reset(ha, bus, target) == 0) {884 /* issued device reset, set wait conditions */885 wait_for_bus = bus;886 wait_for_target = target;887 }888 break;889 890 case BUS_RESET:891 if (qla1280_verbose)892 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "893 "reset.\n", ha->host_no, bus);894 if (qla1280_bus_reset(ha, bus) == 0) {895 /* issued bus reset, set wait conditions */896 wait_for_bus = bus;897 }898 break;899 900 default:901 dprintk(1, "RESET invalid action %d\n", action);902 return FAILED;903 }904 905 /*906 * At this point, the host_lock has been released and retaken907 * by the issuance of the mailbox command.908 * Wait for the command passed in by the mid-layer if it909 * was found by the driver. It might have been returned910 * between eh recovery steps, hence the check of the "found"911 * variable.912 */913 914 if (found >= 0)915 result = _qla1280_wait_for_single_command(ha, sp, &wait);916 917 if (action == ABORT_COMMAND && result != SUCCESS) {918 printk(KERN_WARNING919 "scsi(%li:%i:%i:%i): "920 "Unable to abort command!\n",921 ha->host_no, bus, target, lun);922 }923 924 /*925 * If the command passed in by the mid-layer has been926 * returned by the board, then wait for any additional927 * commands which are supposed to complete based upon928 * the error action.929 *930 * All commands are unconditionally returned during a931 * call to qla1280_abort_isp(), ADAPTER_RESET. No need932 * to wait for them.933 */934 if (result == SUCCESS && wait_for_bus >= 0) {935 result = qla1280_wait_for_pending_commands(ha,936 wait_for_bus, wait_for_target);937 }938 939 dprintk(1, "RESET returning %d\n", result);940 941 LEAVE("qla1280_error_action");942 return result;943}944 945/**************************************************************************946 * qla1280_abort947 * Abort the specified SCSI command(s).948 **************************************************************************/949static int950qla1280_eh_abort(struct scsi_cmnd * cmd)951{952 int rc;953 954 spin_lock_irq(cmd->device->host->host_lock);955 rc = qla1280_error_action(cmd, ABORT_COMMAND);956 spin_unlock_irq(cmd->device->host->host_lock);957 958 return rc;959}960 961/**************************************************************************962 * qla1280_device_reset963 * Reset the specified SCSI device964 **************************************************************************/965static int966qla1280_eh_device_reset(struct scsi_cmnd *cmd)967{968 int rc;969 970 spin_lock_irq(cmd->device->host->host_lock);971 rc = qla1280_error_action(cmd, DEVICE_RESET);972 spin_unlock_irq(cmd->device->host->host_lock);973 974 return rc;975}976 977/**************************************************************************978 * qla1280_bus_reset979 * Reset the specified bus.980 **************************************************************************/981static int982qla1280_eh_bus_reset(struct scsi_cmnd *cmd)983{984 int rc;985 986 spin_lock_irq(cmd->device->host->host_lock);987 rc = qla1280_error_action(cmd, BUS_RESET);988 spin_unlock_irq(cmd->device->host->host_lock);989 990 return rc;991}992 993/**************************************************************************994 * qla1280_adapter_reset995 * Reset the specified adapter (both channels)996 **************************************************************************/997static int998qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)999{1000 int rc = SUCCESS;1001 struct Scsi_Host *shost = cmd->device->host;1002 struct scsi_qla_host *ha = (struct scsi_qla_host *)shost->hostdata;1003 1004 spin_lock_irq(shost->host_lock);1005 if (qla1280_verbose) {1006 printk(KERN_INFO1007 "scsi(%ld): Issued ADAPTER RESET\n",1008 ha->host_no);1009 printk(KERN_INFO "scsi(%ld): I/O processing will "1010 "continue automatically\n", ha->host_no);1011 }1012 ha->flags.reset_active = 1;1013 1014 if (qla1280_abort_isp(ha) != 0) { /* it's dead */1015 rc = FAILED;1016 }1017 1018 ha->flags.reset_active = 0;1019 1020 spin_unlock_irq(shost->host_lock);1021 1022 return rc;1023}1024 1025static int1026qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,1027 sector_t capacity, int geom[])1028{1029 int heads, sectors, cylinders;1030 1031 heads = 64;1032 sectors = 32;1033 cylinders = (unsigned long)capacity / (heads * sectors);1034 if (cylinders > 1024) {1035 heads = 255;1036 sectors = 63;1037 cylinders = (unsigned long)capacity / (heads * sectors);1038 /* if (cylinders > 1023)1039 cylinders = 1023; */1040 }1041 1042 geom[0] = heads;1043 geom[1] = sectors;1044 geom[2] = cylinders;1045 1046 return 0;1047}1048 1049 1050/* disable risc and host interrupts */1051static inline void1052qla1280_disable_intrs(struct scsi_qla_host *ha)1053{1054 WRT_REG_WORD(&ha->iobase->ictrl, 0);1055 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */1056}1057 1058/* enable risc and host interrupts */1059static inline void1060qla1280_enable_intrs(struct scsi_qla_host *ha)1061{1062 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));1063 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */1064}1065 1066/**************************************************************************1067 * qla1280_intr_handler1068 * Handles the H/W interrupt1069 **************************************************************************/1070static irqreturn_t1071qla1280_intr_handler(int irq, void *dev_id)1072{1073 struct scsi_qla_host *ha;1074 struct device_reg __iomem *reg;1075 u16 data;1076 int handled = 0;1077 1078 ENTER_INTR ("qla1280_intr_handler");1079 ha = (struct scsi_qla_host *)dev_id;1080 1081 spin_lock(ha->host->host_lock);1082 1083 ha->isr_count++;1084 reg = ha->iobase;1085 1086 qla1280_disable_intrs(ha);1087 1088 data = qla1280_debounce_register(®->istatus);1089 /* Check for pending interrupts. */1090 if (data & RISC_INT) { 1091 qla1280_isr(ha, &ha->done_q);1092 handled = 1;1093 }1094 if (!list_empty(&ha->done_q))1095 qla1280_done(ha);1096 1097 spin_unlock(ha->host->host_lock);1098 1099 qla1280_enable_intrs(ha);1100 1101 LEAVE_INTR("qla1280_intr_handler");1102 return IRQ_RETVAL(handled);1103}1104 1105 1106static int1107qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)1108{1109 uint8_t mr;1110 uint16_t mb[MAILBOX_REGISTER_COUNT];1111 struct nvram *nv;1112 int status, lun;1113 1114 nv = &ha->nvram;1115 1116 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;1117 1118 /* Set Target Parameters. */1119 mb[0] = MBC_SET_TARGET_PARAMETERS;1120 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);1121 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;1122 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;1123 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;1124 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;1125 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;1126 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;1127 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;1128 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;1129 1130 if (IS_ISP1x160(ha)) {1131 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;1132 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);1133 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |1134 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;1135 mr |= BIT_6;1136 } else {1137 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);1138 }1139 mb[3] |= nv->bus[bus].target[target].sync_period;1140 1141 status = qla1280_mailbox_command(ha, mr, mb);1142 1143 /* Set Device Queue Parameters. */1144 for (lun = 0; lun < MAX_LUNS; lun++) {1145 mb[0] = MBC_SET_DEVICE_QUEUE;1146 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);1147 mb[1] |= lun;1148 mb[2] = nv->bus[bus].max_queue_depth;1149 mb[3] = nv->bus[bus].target[target].execution_throttle;1150 status |= qla1280_mailbox_command(ha, 0x0f, mb);1151 }1152 1153 if (status)1154 printk(KERN_WARNING "scsi(%ld:%i:%i): "1155 "qla1280_set_target_parameters() failed\n",1156 ha->host_no, bus, target);1157 return status;1158}1159 1160 1161/**************************************************************************1162 * qla1280_slave_configure1163 *1164 * Description:1165 * Determines the queue depth for a given device. There are two ways1166 * a queue depth can be obtained for a tagged queueing device. One1167 * way is the default queue depth which is determined by whether1168 * If it is defined, then it is used1169 * as the default queue depth. Otherwise, we use either 4 or 8 as the1170 * default queue depth (dependent on the number of hardware SCBs).1171 **************************************************************************/1172static int1173qla1280_slave_configure(struct scsi_device *device)1174{1175 struct scsi_qla_host *ha;1176 int default_depth = 3;1177 int bus = device->channel;1178 int target = device->id;1179 int status = 0;1180 struct nvram *nv;1181 unsigned long flags;1182 1183 ha = (struct scsi_qla_host *)device->host->hostdata;1184 nv = &ha->nvram;1185 1186 if (qla1280_check_for_dead_scsi_bus(ha, bus))1187 return 1;1188 1189 if (device->tagged_supported &&1190 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {1191 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);1192 } else {1193 scsi_change_queue_depth(device, default_depth);1194 }1195 1196 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;1197 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;1198 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;1199 1200 if (driver_setup.no_sync ||1201 (driver_setup.sync_mask &&1202 (~driver_setup.sync_mask & (1 << target))))1203 nv->bus[bus].target[target].parameter.enable_sync = 0;1204 if (driver_setup.no_wide ||1205 (driver_setup.wide_mask &&1206 (~driver_setup.wide_mask & (1 << target))))1207 nv->bus[bus].target[target].parameter.enable_wide = 0;1208 if (IS_ISP1x160(ha)) {1209 if (driver_setup.no_ppr ||1210 (driver_setup.ppr_mask &&1211 (~driver_setup.ppr_mask & (1 << target))))1212 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;1213 }1214 1215 spin_lock_irqsave(ha->host->host_lock, flags);1216 if (nv->bus[bus].target[target].parameter.enable_sync)1217 status = qla1280_set_target_parameters(ha, bus, target);1218 qla1280_get_target_parameters(ha, device);1219 spin_unlock_irqrestore(ha->host->host_lock, flags);1220 return status;1221}1222 1223 1224/*1225 * qla1280_done1226 * Process completed commands.1227 *1228 * Input:1229 * ha = adapter block pointer.1230 */1231static void1232qla1280_done(struct scsi_qla_host *ha)1233{1234 struct srb *sp;1235 struct list_head *done_q;1236 int bus, target;1237 struct scsi_cmnd *cmd;1238 1239 ENTER("qla1280_done");1240 1241 done_q = &ha->done_q;1242 1243 while (!list_empty(done_q)) {1244 sp = list_entry(done_q->next, struct srb, list);1245 1246 list_del(&sp->list);1247 1248 cmd = sp->cmd;1249 bus = SCSI_BUS_32(cmd);1250 target = SCSI_TCN_32(cmd);1251 1252 switch ((CMD_RESULT(cmd) >> 16)) {1253 case DID_RESET:1254 /* Issue marker command. */1255 if (!ha->flags.abort_isp_active)1256 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);1257 break;1258 case DID_ABORT:1259 sp->flags &= ~SRB_ABORT_PENDING;1260 sp->flags |= SRB_ABORTED;1261 break;1262 default:1263 break;1264 }1265 1266 /* Release memory used for this I/O */1267 scsi_dma_unmap(cmd);1268 1269 /* Call the mid-level driver interrupt handler */1270 ha->actthreads--;1271 1272 if (sp->wait == NULL)1273 scsi_done(cmd);1274 else1275 complete(sp->wait);1276 }1277 LEAVE("qla1280_done");1278}1279 1280/*1281 * Translates a ISP error to a Linux SCSI error1282 */1283static int1284qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)1285{1286 int host_status = DID_ERROR;1287 uint16_t comp_status = le16_to_cpu(sts->comp_status);1288 uint16_t state_flags = le16_to_cpu(sts->state_flags);1289 uint32_t residual_length = le32_to_cpu(sts->residual_length);1290 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);1291#if DEBUG_QLA1280_INTR1292 static char *reason[] = {1293 "DID_OK",1294 "DID_NO_CONNECT",1295 "DID_BUS_BUSY",1296 "DID_TIME_OUT",1297 "DID_BAD_TARGET",1298 "DID_ABORT",1299 "DID_PARITY",1300 "DID_ERROR",1301 "DID_RESET",1302 "DID_BAD_INTR"1303 };1304#endif /* DEBUG_QLA1280_INTR */1305 1306 ENTER("qla1280_return_status");1307 1308#if DEBUG_QLA1280_INTR1309 /*1310 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",1311 comp_status);1312 */1313#endif1314 1315 switch (comp_status) {1316 case CS_COMPLETE:1317 host_status = DID_OK;1318 break;1319 1320 case CS_INCOMPLETE:1321 if (!(state_flags & SF_GOT_BUS))1322 host_status = DID_NO_CONNECT;1323 else if (!(state_flags & SF_GOT_TARGET))1324 host_status = DID_BAD_TARGET;1325 else if (!(state_flags & SF_SENT_CDB))1326 host_status = DID_ERROR;1327 else if (!(state_flags & SF_TRANSFERRED_DATA))1328 host_status = DID_ERROR;1329 else if (!(state_flags & SF_GOT_STATUS))1330 host_status = DID_ERROR;1331 else if (!(state_flags & SF_GOT_SENSE))1332 host_status = DID_ERROR;1333 break;1334 1335 case CS_RESET:1336 host_status = DID_RESET;1337 break;1338 1339 case CS_ABORTED:1340 host_status = DID_ABORT;1341 break;1342 1343 case CS_TIMEOUT:1344 host_status = DID_TIME_OUT;1345 break;1346 1347 case CS_DATA_OVERRUN:1348 dprintk(2, "Data overrun 0x%x\n", residual_length);1349 dprintk(2, "qla1280_return_status: response packet data\n");1350 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);1351 host_status = DID_ERROR;1352 break;1353 1354 case CS_DATA_UNDERRUN:1355 if ((scsi_bufflen(cp) - residual_length) <1356 cp->underflow) {1357 printk(KERN_WARNING1358 "scsi: Underflow detected - retrying "1359 "command.\n");1360 host_status = DID_ERROR;1361 } else {1362 scsi_set_resid(cp, residual_length);1363 host_status = DID_OK;1364 }1365 break;1366 1367 default:1368 host_status = DID_ERROR;1369 break;1370 }1371 1372#if DEBUG_QLA1280_INTR1373 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",1374 reason[host_status], scsi_status);1375#endif1376 1377 LEAVE("qla1280_return_status");1378 1379 return (scsi_status & 0xff) | (host_status << 16);1380}1381 1382/****************************************************************************/1383/* QLogic ISP1280 Hardware Support Functions. */1384/****************************************************************************/1385 1386/*1387 * qla1280_initialize_adapter1388 * Initialize board.1389 *1390 * Input:1391 * ha = adapter block pointer.1392 *1393 * Returns:1394 * 0 = success1395 */1396static int1397qla1280_initialize_adapter(struct scsi_qla_host *ha)1398{1399 struct device_reg __iomem *reg;1400 int status;1401 int bus;1402 unsigned long flags;1403 1404 ENTER("qla1280_initialize_adapter");1405 1406 /* Clear adapter flags. */1407 ha->flags.online = 0;1408 ha->flags.disable_host_adapter = 0;1409 ha->flags.reset_active = 0;1410 ha->flags.abort_isp_active = 0;1411 1412 /* TODO: implement support for the 1040 nvram format */1413 if (IS_ISP1040(ha))1414 driver_setup.no_nvram = 1;1415 1416 dprintk(1, "Configure PCI space for adapter...\n");1417 1418 reg = ha->iobase;1419 1420 /* Insure mailbox registers are free. */1421 WRT_REG_WORD(®->semaphore, 0);1422 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);1423 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);1424 RD_REG_WORD(®->host_cmd);1425 1426 if (qla1280_read_nvram(ha)) {1427 dprintk(2, "qla1280_initialize_adapter: failed to read "1428 "NVRAM\n");1429 }1430 1431 /*1432 * It's necessary to grab the spin here as qla1280_mailbox_command1433 * needs to be able to drop the lock unconditionally to wait1434 * for completion.1435 */1436 spin_lock_irqsave(ha->host->host_lock, flags);1437 1438 status = qla1280_load_firmware(ha);1439 if (status) {1440 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",1441 ha->host_no);1442 goto out;1443 }1444 1445 /* Setup adapter based on NVRAM parameters. */1446 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);1447 qla1280_nvram_config(ha);1448 1449 if (ha->flags.disable_host_adapter) {1450 status = 1;1451 goto out;1452 }1453 1454 status = qla1280_init_rings(ha);1455 if (status)1456 goto out;1457 1458 /* Issue SCSI reset, if we can't reset twice then bus is dead */1459 for (bus = 0; bus < ha->ports; bus++) {1460 if (!ha->bus_settings[bus].disable_scsi_reset &&1461 qla1280_bus_reset(ha, bus) &&1462 qla1280_bus_reset(ha, bus))1463 ha->bus_settings[bus].scsi_bus_dead = 1;1464 }1465 1466 ha->flags.online = 1;1467 out:1468 spin_unlock_irqrestore(ha->host->host_lock, flags);1469 1470 if (status)1471 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");1472 1473 LEAVE("qla1280_initialize_adapter");1474 return status;1475}1476 1477/*1478 * qla1280_request_firmware1479 * Acquire firmware for chip. Retain in memory1480 * for error recovery.1481 *1482 * Input:1483 * ha = adapter block pointer.1484 *1485 * Returns:1486 * Pointer to firmware image or an error code1487 * cast to pointer via ERR_PTR().1488 */1489static const struct firmware *1490qla1280_request_firmware(struct scsi_qla_host *ha)1491{1492 const struct firmware *fw;1493 int err;1494 int index;1495 char *fwname;1496 1497 spin_unlock_irq(ha->host->host_lock);1498 mutex_lock(&qla1280_firmware_mutex);1499 1500 index = ql1280_board_tbl[ha->devnum].fw_index;1501 fw = qla1280_fw_tbl[index].fw;1502 if (fw)1503 goto out;1504 1505 fwname = qla1280_fw_tbl[index].fwname;1506 err = request_firmware(&fw, fwname, &ha->pdev->dev);1507 1508 if (err) {1509 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",1510 fwname, err);1511 fw = ERR_PTR(err);1512 goto unlock;1513 }1514 if ((fw->size % 2) || (fw->size < 6)) {1515 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",1516 fw->size, fwname);1517 release_firmware(fw);1518 fw = ERR_PTR(-EINVAL);1519 goto unlock;1520 }1521 1522 qla1280_fw_tbl[index].fw = fw;1523 1524 out:1525 ha->fwver1 = fw->data[0];1526 ha->fwver2 = fw->data[1];1527 ha->fwver3 = fw->data[2];1528 unlock:1529 mutex_unlock(&qla1280_firmware_mutex);1530 spin_lock_irq(ha->host->host_lock);1531 return fw;1532}1533 1534/*1535 * Chip diagnostics1536 * Test chip for proper operation.1537 *1538 * Input:1539 * ha = adapter block pointer.1540 *1541 * Returns:1542 * 0 = success.1543 */1544static int1545qla1280_chip_diag(struct scsi_qla_host *ha)1546{1547 uint16_t mb[MAILBOX_REGISTER_COUNT];1548 struct device_reg __iomem *reg = ha->iobase;1549 int status = 0;1550 int cnt;1551 uint16_t data;1552 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);1553 1554 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);1555 1556 /* Soft reset chip and wait for it to finish. */1557 WRT_REG_WORD(®->ictrl, ISP_RESET);1558 1559 /*1560 * We can't do a traditional PCI write flush here by reading1561 * back the register. The card will not respond once the reset1562 * is in action and we end up with a machine check exception1563 * instead. Nothing to do but wait and hope for the best.1564 * A portable pci_write_flush(pdev) call would be very useful here.1565 */1566 udelay(20);1567 data = qla1280_debounce_register(®->ictrl);1568 /*1569 * Yet another QLogic gem ;-(1570 */1571 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {1572 udelay(5);1573 data = RD_REG_WORD(®->ictrl);1574 }1575 1576 if (!cnt)1577 goto fail;1578 1579 /* Reset register cleared by chip reset. */1580 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");1581 1582 WRT_REG_WORD(®->cfg_1, 0);1583 1584 /* Reset RISC and disable BIOS which1585 allows RISC to execute out of RAM. */1586 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |1587 HC_RELEASE_RISC | HC_DISABLE_BIOS);1588 1589 RD_REG_WORD(®->id_l); /* Flush PCI write */1590 data = qla1280_debounce_register(®->mailbox0);1591 1592 /*1593 * I *LOVE* this code!1594 */1595 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {1596 udelay(5);1597 data = RD_REG_WORD(®->mailbox0);1598 }1599 1600 if (!cnt)1601 goto fail;1602 1603 /* Check product ID of chip */1604 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");1605 1606 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||1607 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&1608 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||1609 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||1610 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {1611 printk(KERN_INFO "qla1280: Wrong product ID = "1612 "0x%x,0x%x,0x%x,0x%x\n",1613 RD_REG_WORD(®->mailbox1),1614 RD_REG_WORD(®->mailbox2),1615 RD_REG_WORD(®->mailbox3),1616 RD_REG_WORD(®->mailbox4));1617 goto fail;1618 }1619 1620 /*1621 * Enable ints early!!!1622 */1623 qla1280_enable_intrs(ha);1624 1625 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");1626 /* Wrap Incoming Mailboxes Test. */1627 mb[0] = MBC_MAILBOX_REGISTER_TEST;1628 mb[1] = 0xAAAA;1629 mb[2] = 0x5555;1630 mb[3] = 0xAA55;1631 mb[4] = 0x55AA;1632 mb[5] = 0xA5A5;1633 mb[6] = 0x5A5A;1634 mb[7] = 0x2525;1635 1636 status = qla1280_mailbox_command(ha, 0xff, mb);1637 if (status)1638 goto fail;1639 1640 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||1641 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||1642 mb[7] != 0x2525) {1643 printk(KERN_INFO "qla1280: Failed mbox check\n");1644 goto fail;1645 }1646 1647 dprintk(3, "qla1280_chip_diag: exiting normally\n");1648 return 0;1649 fail:1650 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");1651 return status;1652}1653 1654static int1655qla1280_load_firmware_pio(struct scsi_qla_host *ha)1656{1657 /* enter with host_lock acquired */1658 1659 const struct firmware *fw;1660 const __le16 *fw_data;1661 uint16_t risc_address, risc_code_size;1662 uint16_t mb[MAILBOX_REGISTER_COUNT], i;1663 int err = 0;1664 1665 fw = qla1280_request_firmware(ha);1666 if (IS_ERR(fw))1667 return PTR_ERR(fw);1668 1669 fw_data = (const __le16 *)&fw->data[0];1670 ha->fwstart = __le16_to_cpu(fw_data[2]);1671 1672 /* Load RISC code. */1673 risc_address = ha->fwstart;1674 fw_data = (const __le16 *)&fw->data[6];1675 risc_code_size = (fw->size - 6) / 2;1676 1677 for (i = 0; i < risc_code_size; i++) {1678 mb[0] = MBC_WRITE_RAM_WORD;1679 mb[1] = risc_address + i;1680 mb[2] = __le16_to_cpu(fw_data[i]);1681 1682 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);1683 if (err) {1684 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",1685 ha->host_no);1686 break;1687 }1688 }1689 1690 return err;1691}1692 1693#ifdef QLA_64BIT_PTR1694#define LOAD_CMD MBC_LOAD_RAM_A64_ROM1695#define DUMP_CMD MBC_DUMP_RAM_A64_ROM1696#define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)1697#else1698#define LOAD_CMD MBC_LOAD_RAM1699#define DUMP_CMD MBC_DUMP_RAM1700#define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)1701#endif1702 1703#define DUMP_IT_BACK 0 /* for debug of RISC loading */1704static int1705qla1280_load_firmware_dma(struct scsi_qla_host *ha)1706{1707 /* enter with host_lock acquired */1708 const struct firmware *fw;1709 const __le16 *fw_data;1710 uint16_t risc_address, risc_code_size;1711 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;1712 int err = 0, num, i;1713#if DUMP_IT_BACK1714 uint8_t *sp, *tbuf;1715 dma_addr_t p_tbuf;1716 1717 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);1718 if (!tbuf)1719 return -ENOMEM;1720#endif1721 1722 fw = qla1280_request_firmware(ha);1723 if (IS_ERR(fw))1724 return PTR_ERR(fw);1725 1726 fw_data = (const __le16 *)&fw->data[0];1727 ha->fwstart = __le16_to_cpu(fw_data[2]);1728 1729 /* Load RISC code. */1730 risc_address = ha->fwstart;1731 fw_data = (const __le16 *)&fw->data[6];1732 risc_code_size = (fw->size - 6) / 2;1733 1734 dprintk(1, "%s: DMA RISC code (%i) words\n",1735 __func__, risc_code_size);1736 1737 num = 0;1738 while (risc_code_size > 0) {1739 int warn __attribute__((unused)) = 0;1740 1741 cnt = 2000 >> 1;1742 1743 if (cnt > risc_code_size)1744 cnt = risc_code_size;1745 1746 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"1747 "%d,%d(0x%x)\n",1748 fw_data, cnt, num, risc_address);1749 for(i = 0; i < cnt; i++)1750 ((__le16 *)ha->request_ring)[i] = fw_data[i];1751 1752 mb[0] = LOAD_CMD;1753 mb[1] = risc_address;1754 mb[4] = cnt;1755 mb[3] = ha->request_dma & 0xffff;1756 mb[2] = (ha->request_dma >> 16) & 0xffff;1757 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;1758 mb[6] = upper_32_bits(ha->request_dma) >> 16;1759 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",1760 __func__, mb[0],1761 (void *)(long)ha->request_dma,1762 mb[6], mb[7], mb[2], mb[3]);1763 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);1764 if (err) {1765 printk(KERN_ERR "scsi(%li): Failed to load partial "1766 "segment of f\n", ha->host_no);1767 goto out;1768 }1769 1770#if DUMP_IT_BACK1771 mb[0] = DUMP_CMD;1772 mb[1] = risc_address;1773 mb[4] = cnt;1774 mb[3] = p_tbuf & 0xffff;1775 mb[2] = (p_tbuf >> 16) & 0xffff;1776 mb[7] = upper_32_bits(p_tbuf) & 0xffff;1777 mb[6] = upper_32_bits(p_tbuf) >> 16;1778 1779 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);1780 if (err) {1781 printk(KERN_ERR1782 "Failed to dump partial segment of f/w\n");1783 goto out;1784 }1785 sp = (uint8_t *)ha->request_ring;1786 for (i = 0; i < (cnt << 1); i++) {1787 if (tbuf[i] != sp[i] && warn++ < 10) {1788 printk(KERN_ERR "%s: FW compare error @ "1789 "byte(0x%x) loop#=%x\n",1790 __func__, i, num);1791 printk(KERN_ERR "%s: FWbyte=%x "1792 "FWfromChip=%x\n",1793 __func__, sp[i], tbuf[i]);1794 /*break; */1795 }1796 }1797#endif1798 risc_address += cnt;1799 risc_code_size = risc_code_size - cnt;1800 fw_data = fw_data + cnt;1801 num++;1802 }1803 1804 out:1805#if DUMP_IT_BACK1806 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);1807#endif1808 return err;1809}1810 1811static int1812qla1280_start_firmware(struct scsi_qla_host *ha)1813{1814 uint16_t mb[MAILBOX_REGISTER_COUNT];1815 int err;1816 1817 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",1818 __func__);1819 1820 /* Verify checksum of loaded RISC code. */1821 mb[0] = MBC_VERIFY_CHECKSUM;1822 /* mb[1] = ql12_risc_code_addr01; */1823 mb[1] = ha->fwstart;1824 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);1825 if (err) {1826 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);1827 return err;1828 }1829 1830 /* Start firmware execution. */1831 dprintk(1, "%s: start firmware running.\n", __func__);1832 mb[0] = MBC_EXECUTE_FIRMWARE;1833 mb[1] = ha->fwstart;1834 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);1835 if (err) {1836 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",1837 ha->host_no);1838 }1839 1840 return err;1841}1842 1843static int1844qla1280_load_firmware(struct scsi_qla_host *ha)1845{1846 /* enter with host_lock taken */1847 int err;1848 1849 err = qla1280_chip_diag(ha);1850 if (err)1851 goto out;1852 if (IS_ISP1040(ha))1853 err = qla1280_load_firmware_pio(ha);1854 else1855 err = qla1280_load_firmware_dma(ha);1856 if (err)1857 goto out;1858 err = qla1280_start_firmware(ha);1859 out:1860 return err;1861}1862 1863/*1864 * Initialize rings1865 *1866 * Input:1867 * ha = adapter block pointer.1868 * ha->request_ring = request ring virtual address1869 * ha->response_ring = response ring virtual address1870 * ha->request_dma = request ring physical address1871 * ha->response_dma = response ring physical address1872 *1873 * Returns:1874 * 0 = success.1875 */1876static int1877qla1280_init_rings(struct scsi_qla_host *ha)1878{1879 uint16_t mb[MAILBOX_REGISTER_COUNT];1880 int status = 0;1881 1882 ENTER("qla1280_init_rings");1883 1884 /* Clear outstanding commands array. */1885 memset(ha->outstanding_cmds, 0,1886 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);1887 1888 /* Initialize request queue. */1889 ha->request_ring_ptr = ha->request_ring;1890 ha->req_ring_index = 0;1891 ha->req_q_cnt = REQUEST_ENTRY_CNT;1892 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */1893 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;1894 mb[1] = REQUEST_ENTRY_CNT;1895 mb[3] = ha->request_dma & 0xffff;1896 mb[2] = (ha->request_dma >> 16) & 0xffff;1897 mb[4] = 0;1898 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;1899 mb[6] = upper_32_bits(ha->request_dma) >> 16;1900 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |1901 BIT_3 | BIT_2 | BIT_1 | BIT_0,1902 &mb[0]))) {1903 /* Initialize response queue. */1904 ha->response_ring_ptr = ha->response_ring;1905 ha->rsp_ring_index = 0;1906 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */1907 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;1908 mb[1] = RESPONSE_ENTRY_CNT;1909 mb[3] = ha->response_dma & 0xffff;1910 mb[2] = (ha->response_dma >> 16) & 0xffff;1911 mb[5] = 0;1912 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;1913 mb[6] = upper_32_bits(ha->response_dma) >> 16;1914 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |1915 BIT_3 | BIT_2 | BIT_1 | BIT_0,1916 &mb[0]);1917 }1918 1919 if (status)1920 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");1921 1922 LEAVE("qla1280_init_rings");1923 return status;1924}1925 1926static void1927qla1280_print_settings(struct nvram *nv)1928{1929 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",1930 nv->bus[0].config_1.initiator_id);1931 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",1932 nv->bus[1].config_1.initiator_id);1933 1934 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",1935 nv->bus[0].bus_reset_delay);1936 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",1937 nv->bus[1].bus_reset_delay);1938 1939 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);1940 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);1941 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);1942 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);1943 1944 dprintk(1, "qla1280 : async data setup time[0]=%d\n",1945 nv->bus[0].config_2.async_data_setup_time);1946 dprintk(1, "qla1280 : async data setup time[1]=%d\n",1947 nv->bus[1].config_2.async_data_setup_time);1948 1949 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",1950 nv->bus[0].config_2.req_ack_active_negation);1951 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",1952 nv->bus[1].config_2.req_ack_active_negation);1953 1954 dprintk(1, "qla1280 : data line active negation[0]=%d\n",1955 nv->bus[0].config_2.data_line_active_negation);1956 dprintk(1, "qla1280 : data line active negation[1]=%d\n",1957 nv->bus[1].config_2.data_line_active_negation);1958 1959 dprintk(1, "qla1280 : disable loading risc code=%d\n",1960 nv->cntr_flags_1.disable_loading_risc_code);1961 1962 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",1963 nv->cntr_flags_1.enable_64bit_addressing);1964 1965 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",1966 nv->bus[0].selection_timeout);1967 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",1968 nv->bus[1].selection_timeout);1969 1970 dprintk(1, "qla1280 : max queue depth[0]=%d\n",1971 nv->bus[0].max_queue_depth);1972 dprintk(1, "qla1280 : max queue depth[1]=%d\n",1973 nv->bus[1].max_queue_depth);1974}1975 1976static void1977qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)1978{1979 struct nvram *nv = &ha->nvram;1980 1981 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;1982 nv->bus[bus].target[target].parameter.auto_request_sense = 1;1983 nv->bus[bus].target[target].parameter.tag_queuing = 1;1984 nv->bus[bus].target[target].parameter.enable_sync = 1;1985#if 1 /* Some SCSI Processors do not seem to like this */1986 nv->bus[bus].target[target].parameter.enable_wide = 1;1987#endif1988 nv->bus[bus].target[target].execution_throttle =1989 nv->bus[bus].max_queue_depth - 1;1990 nv->bus[bus].target[target].parameter.parity_checking = 1;1991 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;1992 1993 if (IS_ISP1x160(ha)) {1994 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;1995 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;1996 nv->bus[bus].target[target].sync_period = 9;1997 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;1998 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;1999 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;2000 } else {2001 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;2002 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;2003 nv->bus[bus].target[target].sync_period = 10;2004 }2005}2006 2007static void2008qla1280_set_defaults(struct scsi_qla_host *ha)2009{2010 struct nvram *nv = &ha->nvram;2011 int bus, target;2012 2013 dprintk(1, "Using defaults for NVRAM: \n");2014 memset(nv, 0, sizeof(struct nvram));2015 2016 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */2017 nv->firmware_feature.f.enable_fast_posting = 1;2018 nv->firmware_feature.f.disable_synchronous_backoff = 1;2019 nv->termination.scsi_bus_0_control = 3;2020 nv->termination.scsi_bus_1_control = 3;2021 nv->termination.auto_term_support = 1;2022 2023 /*2024 * Set default FIFO magic - What appropriate values would be here2025 * is unknown. This is what I have found testing with 12160s.2026 *2027 * Now, I would love the magic decoder ring for this one, the2028 * header file provided by QLogic seems to be bogus or incomplete2029 * at best.2030 */2031 nv->isp_config.burst_enable = 1;2032 if (IS_ISP1040(ha))2033 nv->isp_config.fifo_threshold |= 3;2034 else2035 nv->isp_config.fifo_threshold |= 4;2036 2037 if (IS_ISP1x160(ha))2038 nv->isp_parameter = 0x01; /* fast memory enable */2039 2040 for (bus = 0; bus < MAX_BUSES; bus++) {2041 nv->bus[bus].config_1.initiator_id = 7;2042 nv->bus[bus].config_2.req_ack_active_negation = 1;2043 nv->bus[bus].config_2.data_line_active_negation = 1;2044 nv->bus[bus].selection_timeout = 250;2045 nv->bus[bus].max_queue_depth = 32;2046 2047 if (IS_ISP1040(ha)) {2048 nv->bus[bus].bus_reset_delay = 3;2049 nv->bus[bus].config_2.async_data_setup_time = 6;2050 nv->bus[bus].retry_delay = 1;2051 } else {2052 nv->bus[bus].bus_reset_delay = 5;2053 nv->bus[bus].config_2.async_data_setup_time = 8;2054 }2055 2056 for (target = 0; target < MAX_TARGETS; target++)2057 qla1280_set_target_defaults(ha, bus, target);2058 }2059}2060 2061static int2062qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)2063{2064 struct nvram *nv = &ha->nvram;2065 uint16_t mb[MAILBOX_REGISTER_COUNT];2066 int status, lun;2067 uint16_t flag;2068 2069 /* Set Target Parameters. */2070 mb[0] = MBC_SET_TARGET_PARAMETERS;2071 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);2072 2073 /*2074 * Do not enable sync and ppr for the initial INQUIRY run. We2075 * enable this later if we determine the target actually2076 * supports it.2077 */2078 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE2079 | TP_WIDE | TP_PARITY | TP_DISCONNECT);2080 2081 if (IS_ISP1x160(ha))2082 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;2083 else2084 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;2085 mb[3] |= nv->bus[bus].target[target].sync_period;2086 status = qla1280_mailbox_command(ha, 0x0f, mb);2087 2088 /* Save Tag queuing enable flag. */2089 flag = (BIT_0 << target);2090 if (nv->bus[bus].target[target].parameter.tag_queuing)2091 ha->bus_settings[bus].qtag_enables |= flag;2092 2093 /* Save Device enable flag. */2094 if (IS_ISP1x160(ha)) {2095 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)2096 ha->bus_settings[bus].device_enables |= flag;2097 ha->bus_settings[bus].lun_disables |= 0;2098 } else {2099 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)2100 ha->bus_settings[bus].device_enables |= flag;2101 /* Save LUN disable flag. */2102 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)2103 ha->bus_settings[bus].lun_disables |= flag;2104 }2105 2106 /* Set Device Queue Parameters. */2107 for (lun = 0; lun < MAX_LUNS; lun++) {2108 mb[0] = MBC_SET_DEVICE_QUEUE;2109 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);2110 mb[1] |= lun;2111 mb[2] = nv->bus[bus].max_queue_depth;2112 mb[3] = nv->bus[bus].target[target].execution_throttle;2113 status |= qla1280_mailbox_command(ha, 0x0f, mb);2114 }2115 2116 return status;2117}2118 2119static int2120qla1280_config_bus(struct scsi_qla_host *ha, int bus)2121{2122 struct nvram *nv = &ha->nvram;2123 uint16_t mb[MAILBOX_REGISTER_COUNT];2124 int target, status;2125 2126 /* SCSI Reset Disable. */2127 ha->bus_settings[bus].disable_scsi_reset =2128 nv->bus[bus].config_1.scsi_reset_disable;2129 2130 /* Initiator ID. */2131 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;2132 mb[0] = MBC_SET_INITIATOR_ID;2133 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :2134 ha->bus_settings[bus].id;2135 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);2136 2137 /* Reset Delay. */2138 ha->bus_settings[bus].bus_reset_delay =2139 nv->bus[bus].bus_reset_delay;2140 2141 /* Command queue depth per device. */2142 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;2143 2144 /* Set target parameters. */2145 for (target = 0; target < MAX_TARGETS; target++)2146 status |= qla1280_config_target(ha, bus, target);2147 2148 return status;2149}2150 2151static int2152qla1280_nvram_config(struct scsi_qla_host *ha)2153{2154 struct device_reg __iomem *reg = ha->iobase;2155 struct nvram *nv = &ha->nvram;2156 int bus, target, status = 0;2157 uint16_t mb[MAILBOX_REGISTER_COUNT];2158 2159 ENTER("qla1280_nvram_config");2160 2161 if (ha->nvram_valid) {2162 /* Always force AUTO sense for LINUX SCSI */2163 for (bus = 0; bus < MAX_BUSES; bus++)2164 for (target = 0; target < MAX_TARGETS; target++) {2165 nv->bus[bus].target[target].parameter.2166 auto_request_sense = 1;2167 }2168 } else {2169 qla1280_set_defaults(ha);2170 }2171 2172 qla1280_print_settings(nv);2173 2174 /* Disable RISC load of firmware. */2175 ha->flags.disable_risc_code_load =2176 nv->cntr_flags_1.disable_loading_risc_code;2177 2178 if (IS_ISP1040(ha)) {2179 uint16_t hwrev, cfg1, cdma_conf;2180 2181 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;2182 2183 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);2184 cdma_conf = RD_REG_WORD(®->cdma_cfg);2185 2186 /* Busted fifo, says mjacob. */2187 if (hwrev != ISP_CFG0_1040A)2188 cfg1 |= nv->isp_config.fifo_threshold << 4;2189 2190 cfg1 |= nv->isp_config.burst_enable << 2;2191 WRT_REG_WORD(®->cfg_1, cfg1);2192 2193 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);2194 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);2195 } else {2196 uint16_t cfg1, term;2197 2198 /* Set ISP hardware DMA burst */2199 cfg1 = nv->isp_config.fifo_threshold << 4;2200 cfg1 |= nv->isp_config.burst_enable << 2;2201 /* Enable DMA arbitration on dual channel controllers */2202 if (ha->ports > 1)2203 cfg1 |= BIT_13;2204 WRT_REG_WORD(®->cfg_1, cfg1);2205 2206 /* Set SCSI termination. */2207 WRT_REG_WORD(®->gpio_enable,2208 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);2209 term = nv->termination.scsi_bus_1_control;2210 term |= nv->termination.scsi_bus_0_control << 2;2211 term |= nv->termination.auto_term_support << 7;2212 RD_REG_WORD(®->id_l); /* Flush PCI write */2213 WRT_REG_WORD(®->gpio_data, term);2214 }2215 RD_REG_WORD(®->id_l); /* Flush PCI write */2216 2217 /* ISP parameter word. */2218 mb[0] = MBC_SET_SYSTEM_PARAMETER;2219 mb[1] = nv->isp_parameter;2220 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);2221 2222 if (IS_ISP1x40(ha)) {2223 /* clock rate - for qla1240 and older, only */2224 mb[0] = MBC_SET_CLOCK_RATE;2225 mb[1] = 40;2226 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);2227 }2228 2229 /* Firmware feature word. */2230 mb[0] = MBC_SET_FIRMWARE_FEATURES;2231 mb[1] = nv->firmware_feature.f.enable_fast_posting;2232 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;2233 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;2234 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);2235 2236 /* Retry count and delay. */2237 mb[0] = MBC_SET_RETRY_COUNT;2238 mb[1] = nv->bus[0].retry_count;2239 mb[2] = nv->bus[0].retry_delay;2240 mb[6] = nv->bus[1].retry_count;2241 mb[7] = nv->bus[1].retry_delay;2242 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |2243 BIT_1 | BIT_0, &mb[0]);2244 2245 /* ASYNC data setup time. */2246 mb[0] = MBC_SET_ASYNC_DATA_SETUP;2247 mb[1] = nv->bus[0].config_2.async_data_setup_time;2248 mb[2] = nv->bus[1].config_2.async_data_setup_time;2249 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);2250 2251 /* Active negation states. */2252 mb[0] = MBC_SET_ACTIVE_NEGATION;2253 mb[1] = 0;2254 if (nv->bus[0].config_2.req_ack_active_negation)2255 mb[1] |= BIT_5;2256 if (nv->bus[0].config_2.data_line_active_negation)2257 mb[1] |= BIT_4;2258 mb[2] = 0;2259 if (nv->bus[1].config_2.req_ack_active_negation)2260 mb[2] |= BIT_5;2261 if (nv->bus[1].config_2.data_line_active_negation)2262 mb[2] |= BIT_4;2263 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);2264 2265 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;2266 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */2267 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);2268 2269 /* thingy */2270 mb[0] = MBC_SET_PCI_CONTROL;2271 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */2272 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */2273 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);2274 2275 mb[0] = MBC_SET_TAG_AGE_LIMIT;2276 mb[1] = 8;2277 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);2278 2279 /* Selection timeout. */2280 mb[0] = MBC_SET_SELECTION_TIMEOUT;2281 mb[1] = nv->bus[0].selection_timeout;2282 mb[2] = nv->bus[1].selection_timeout;2283 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);2284 2285 for (bus = 0; bus < ha->ports; bus++)2286 status |= qla1280_config_bus(ha, bus);2287 2288 if (status)2289 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");2290 2291 LEAVE("qla1280_nvram_config");2292 return status;2293}2294 2295/*2296 * Get NVRAM data word2297 * Calculates word position in NVRAM and calls request routine to2298 * get the word from NVRAM.2299 *2300 * Input:2301 * ha = adapter block pointer.2302 * address = NVRAM word address.2303 *2304 * Returns:2305 * data word.2306 */2307static uint16_t2308qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)2309{2310 uint32_t nv_cmd;2311 uint16_t data;2312 2313 nv_cmd = address << 16;2314 nv_cmd |= NV_READ_OP;2315 2316 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));2317 2318 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "2319 "0x%x", data);2320 2321 return data;2322}2323 2324/*2325 * NVRAM request2326 * Sends read command to NVRAM and gets data from NVRAM.2327 *2328 * Input:2329 * ha = adapter block pointer.2330 * nv_cmd = Bit 26 = start bit2331 * Bit 25, 24 = opcode2332 * Bit 23-16 = address2333 * Bit 15-0 = write data2334 *2335 * Returns:2336 * data word.2337 */2338static uint16_t2339qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)2340{2341 struct device_reg __iomem *reg = ha->iobase;2342 int cnt;2343 uint16_t data = 0;2344 uint16_t reg_data;2345 2346 /* Send command to NVRAM. */2347 2348 nv_cmd <<= 5;2349 for (cnt = 0; cnt < 11; cnt++) {2350 if (nv_cmd & BIT_31)2351 qla1280_nv_write(ha, NV_DATA_OUT);2352 else2353 qla1280_nv_write(ha, 0);2354 nv_cmd <<= 1;2355 }2356 2357 /* Read data from NVRAM. */2358 2359 for (cnt = 0; cnt < 16; cnt++) {2360 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));2361 RD_REG_WORD(®->id_l); /* Flush PCI write */2362 NVRAM_DELAY();2363 data <<= 1;2364 reg_data = RD_REG_WORD(®->nvram);2365 if (reg_data & NV_DATA_IN)2366 data |= BIT_0;2367 WRT_REG_WORD(®->nvram, NV_SELECT);2368 RD_REG_WORD(®->id_l); /* Flush PCI write */2369 NVRAM_DELAY();2370 }2371 2372 /* Deselect chip. */2373 2374 WRT_REG_WORD(®->nvram, NV_DESELECT);2375 RD_REG_WORD(®->id_l); /* Flush PCI write */2376 NVRAM_DELAY();2377 2378 return data;2379}2380 2381static void2382qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)2383{2384 struct device_reg __iomem *reg = ha->iobase;2385 2386 WRT_REG_WORD(®->nvram, data | NV_SELECT);2387 RD_REG_WORD(®->id_l); /* Flush PCI write */2388 NVRAM_DELAY();2389 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);2390 RD_REG_WORD(®->id_l); /* Flush PCI write */2391 NVRAM_DELAY();2392 WRT_REG_WORD(®->nvram, data | NV_SELECT);2393 RD_REG_WORD(®->id_l); /* Flush PCI write */2394 NVRAM_DELAY();2395}2396 2397/*2398 * Mailbox Command2399 * Issue mailbox command and waits for completion.2400 *2401 * Input:2402 * ha = adapter block pointer.2403 * mr = mailbox registers to load.2404 * mb = data pointer for mailbox registers.2405 *2406 * Output:2407 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.2408 *2409 * Returns:2410 * 0 = success2411 */2412static int2413qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)2414{2415 struct device_reg __iomem *reg = ha->iobase;2416 int status = 0;2417 int cnt;2418 uint16_t *optr, *iptr;2419 uint16_t __iomem *mptr;2420 DECLARE_COMPLETION_ONSTACK(wait);2421 2422 ENTER("qla1280_mailbox_command");2423 2424 if (ha->mailbox_wait) {2425 printk(KERN_ERR "Warning mailbox wait already in use!\n");2426 }2427 ha->mailbox_wait = &wait;2428 2429 /*2430 * We really should start out by verifying that the mailbox is2431 * available before starting sending the command data2432 */2433 /* Load mailbox registers. */2434 mptr = (uint16_t __iomem *) ®->mailbox0;2435 iptr = mb;2436 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {2437 if (mr & BIT_0) {2438 WRT_REG_WORD(mptr, (*iptr));2439 }2440 2441 mr >>= 1;2442 mptr++;2443 iptr++;2444 }2445 2446 /* Issue set host interrupt command. */2447 2448 /* set up a timer just in case we're really jammed */2449 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);2450 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);2451 2452 spin_unlock_irq(ha->host->host_lock);2453 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);2454 qla1280_debounce_register(®->istatus);2455 2456 wait_for_completion(&wait);2457 del_timer_sync(&ha->mailbox_timer);2458 2459 spin_lock_irq(ha->host->host_lock);2460 2461 ha->mailbox_wait = NULL;2462 2463 /* Check for mailbox command timeout. */2464 if (ha->mailbox_out[0] != MBS_CMD_CMP) {2465 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "2466 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "2467 "0x%04x\n", 2468 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));2469 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",2470 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),2471 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));2472 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",2473 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),2474 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));2475 status = 1;2476 }2477 2478 /* Load return mailbox registers. */2479 optr = mb;2480 iptr = (uint16_t *) &ha->mailbox_out[0];2481 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));2482 2483 if (ha->flags.reset_marker)2484 qla1280_rst_aen(ha);2485 2486 if (status)2487 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "2488 "0x%x ****\n", mb[0]);2489 2490 LEAVE("qla1280_mailbox_command");2491 return status;2492}2493 2494/*2495 * qla1280_poll2496 * Polls ISP for interrupts.2497 *2498 * Input:2499 * ha = adapter block pointer.2500 */2501static void2502qla1280_poll(struct scsi_qla_host *ha)2503{2504 struct device_reg __iomem *reg = ha->iobase;2505 uint16_t data;2506 LIST_HEAD(done_q);2507 2508 /* ENTER("qla1280_poll"); */2509 2510 /* Check for pending interrupts. */2511 data = RD_REG_WORD(®->istatus);2512 if (data & RISC_INT)2513 qla1280_isr(ha, &done_q);2514 2515 if (!ha->mailbox_wait) {2516 if (ha->flags.reset_marker)2517 qla1280_rst_aen(ha);2518 }2519 2520 if (!list_empty(&done_q))2521 qla1280_done(ha);2522 2523 /* LEAVE("qla1280_poll"); */2524}2525 2526/*2527 * qla1280_bus_reset2528 * Issue SCSI bus reset.2529 *2530 * Input:2531 * ha = adapter block pointer.2532 * bus = SCSI bus number.2533 *2534 * Returns:2535 * 0 = success2536 */2537static int2538qla1280_bus_reset(struct scsi_qla_host *ha, int bus)2539{2540 uint16_t mb[MAILBOX_REGISTER_COUNT];2541 uint16_t reset_delay;2542 int status;2543 2544 dprintk(3, "qla1280_bus_reset: entered\n");2545 2546 if (qla1280_verbose)2547 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",2548 ha->host_no, bus);2549 2550 reset_delay = ha->bus_settings[bus].bus_reset_delay;2551 mb[0] = MBC_BUS_RESET;2552 mb[1] = reset_delay;2553 mb[2] = (uint16_t) bus;2554 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);2555 2556 if (status) {2557 if (ha->bus_settings[bus].failed_reset_count > 2)2558 ha->bus_settings[bus].scsi_bus_dead = 1;2559 ha->bus_settings[bus].failed_reset_count++;2560 } else {2561 spin_unlock_irq(ha->host->host_lock);2562 ssleep(reset_delay);2563 spin_lock_irq(ha->host->host_lock);2564 2565 ha->bus_settings[bus].scsi_bus_dead = 0;2566 ha->bus_settings[bus].failed_reset_count = 0;2567 ha->bus_settings[bus].reset_marker = 0;2568 /* Issue marker command. */2569 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);2570 }2571 2572 /*2573 * We should probably call qla1280_set_target_parameters()2574 * here as well for all devices on the bus.2575 */2576 2577 if (status)2578 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");2579 else2580 dprintk(3, "qla1280_bus_reset: exiting normally\n");2581 2582 return status;2583}2584 2585/*2586 * qla1280_device_reset2587 * Issue bus device reset message to the target.2588 *2589 * Input:2590 * ha = adapter block pointer.2591 * bus = SCSI BUS number.2592 * target = SCSI ID.2593 *2594 * Returns:2595 * 0 = success2596 */2597static int2598qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)2599{2600 uint16_t mb[MAILBOX_REGISTER_COUNT];2601 int status;2602 2603 ENTER("qla1280_device_reset");2604 2605 mb[0] = MBC_ABORT_TARGET;2606 mb[1] = (bus ? (target | BIT_7) : target) << 8;2607 mb[2] = 1;2608 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);2609 2610 /* Issue marker command. */2611 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);2612 2613 if (status)2614 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");2615 2616 LEAVE("qla1280_device_reset");2617 return status;2618}2619 2620/*2621 * qla1280_abort_command2622 * Abort command aborts a specified IOCB.2623 *2624 * Input:2625 * ha = adapter block pointer.2626 * sp = SB structure pointer.2627 *2628 * Returns:2629 * 0 = success2630 */2631static int2632qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)2633{2634 uint16_t mb[MAILBOX_REGISTER_COUNT];2635 unsigned int bus, target, lun;2636 int status;2637 2638 ENTER("qla1280_abort_command");2639 2640 bus = SCSI_BUS_32(sp->cmd);2641 target = SCSI_TCN_32(sp->cmd);2642 lun = SCSI_LUN_32(sp->cmd);2643 2644 sp->flags |= SRB_ABORT_PENDING;2645 2646 mb[0] = MBC_ABORT_COMMAND;2647 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;2648 mb[2] = handle >> 16;2649 mb[3] = handle & 0xffff;2650 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);2651 2652 if (status) {2653 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");2654 sp->flags &= ~SRB_ABORT_PENDING;2655 }2656 2657 2658 LEAVE("qla1280_abort_command");2659 return status;2660}2661 2662/*2663 * qla1280_reset_adapter2664 * Reset adapter.2665 *2666 * Input:2667 * ha = adapter block pointer.2668 */2669static void2670qla1280_reset_adapter(struct scsi_qla_host *ha)2671{2672 struct device_reg __iomem *reg = ha->iobase;2673 2674 ENTER("qla1280_reset_adapter");2675 2676 /* Disable ISP chip */2677 ha->flags.online = 0;2678 WRT_REG_WORD(®->ictrl, ISP_RESET);2679 WRT_REG_WORD(®->host_cmd,2680 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);2681 RD_REG_WORD(®->id_l); /* Flush PCI write */2682 2683 LEAVE("qla1280_reset_adapter");2684}2685 2686/*2687 * Issue marker command.2688 * Function issues marker IOCB.2689 *2690 * Input:2691 * ha = adapter block pointer.2692 * bus = SCSI BUS number2693 * id = SCSI ID2694 * lun = SCSI LUN2695 * type = marker modifier2696 */2697static void2698qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)2699{2700 struct mrk_entry *pkt;2701 2702 ENTER("qla1280_marker");2703 2704 /* Get request packet. */2705 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {2706 pkt->entry_type = MARKER_TYPE;2707 pkt->lun = (uint8_t) lun;2708 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);2709 pkt->modifier = type;2710 pkt->entry_status = 0;2711 2712 /* Issue command to ISP */2713 qla1280_isp_cmd(ha);2714 }2715 2716 LEAVE("qla1280_marker");2717}2718 2719 2720/*2721 * qla1280_64bit_start_scsi2722 * The start SCSI is responsible for building request packets on2723 * request ring and modifying ISP input pointer.2724 *2725 * Input:2726 * ha = adapter block pointer.2727 * sp = SB structure pointer.2728 *2729 * Returns:2730 * 0 = success, was able to issue command.2731 */2732#ifdef QLA_64BIT_PTR2733static int2734qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)2735{2736 struct device_reg __iomem *reg = ha->iobase;2737 struct scsi_cmnd *cmd = sp->cmd;2738 cmd_a64_entry_t *pkt;2739 __le32 *dword_ptr;2740 dma_addr_t dma_handle;2741 int status = 0;2742 int cnt;2743 int req_cnt;2744 int seg_cnt;2745 u8 dir;2746 2747 ENTER("qla1280_64bit_start_scsi:");2748 2749 /* Calculate number of entries and segments required. */2750 req_cnt = 1;2751 seg_cnt = scsi_dma_map(cmd);2752 if (seg_cnt > 0) {2753 if (seg_cnt > 2) {2754 req_cnt += (seg_cnt - 2) / 5;2755 if ((seg_cnt - 2) % 5)2756 req_cnt++;2757 }2758 } else if (seg_cnt < 0) {2759 status = 1;2760 goto out;2761 }2762 2763 if ((req_cnt + 2) >= ha->req_q_cnt) {2764 /* Calculate number of free request entries. */2765 cnt = RD_REG_WORD(®->mailbox4);2766 if (ha->req_ring_index < cnt)2767 ha->req_q_cnt = cnt - ha->req_ring_index;2768 else2769 ha->req_q_cnt =2770 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);2771 }2772 2773 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",2774 ha->req_q_cnt, seg_cnt);2775 2776 /* If room for request in request ring. */2777 if ((req_cnt + 2) >= ha->req_q_cnt) {2778 status = SCSI_MLQUEUE_HOST_BUSY;2779 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="2780 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,2781 req_cnt);2782 goto out;2783 }2784 2785 /* Check for room in outstanding command list. */2786 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&2787 ha->outstanding_cmds[cnt] != NULL; cnt++);2788 2789 if (cnt >= MAX_OUTSTANDING_COMMANDS) {2790 status = SCSI_MLQUEUE_HOST_BUSY;2791 dprintk(2, "qla1280_start_scsi: NO ROOM IN "2792 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);2793 goto out;2794 }2795 2796 ha->outstanding_cmds[cnt] = sp;2797 ha->req_q_cnt -= req_cnt;2798 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);2799 2800 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,2801 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));2802 dprintk(2, " bus %i, target %i, lun %i\n",2803 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));2804 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);2805 2806 /*2807 * Build command packet.2808 */2809 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;2810 2811 pkt->entry_type = COMMAND_A64_TYPE;2812 pkt->entry_count = (uint8_t) req_cnt;2813 pkt->sys_define = (uint8_t) ha->req_ring_index;2814 pkt->entry_status = 0;2815 pkt->handle = cpu_to_le32(cnt);2816 2817 /* Zero out remaining portion of packet. */2818 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));2819 2820 /* Set ISP command timeout. */2821 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);2822 2823 /* Set device target ID and LUN */2824 pkt->lun = SCSI_LUN_32(cmd);2825 pkt->target = SCSI_BUS_32(cmd) ?2826 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);2827 2828 /* Enable simple tag queuing if device supports it. */2829 if (cmd->device->simple_tags)2830 pkt->control_flags |= cpu_to_le16(BIT_3);2831 2832 /* Load SCSI command packet. */2833 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));2834 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));2835 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */2836 2837 /* Set transfer direction. */2838 dir = qla1280_data_direction(cmd);2839 pkt->control_flags |= cpu_to_le16(dir);2840 2841 /* Set total data segment count. */2842 pkt->dseg_count = cpu_to_le16(seg_cnt);2843 2844 /*2845 * Load data segments.2846 */2847 if (seg_cnt) { /* If data transfer. */2848 struct scatterlist *sg, *s;2849 int remseg = seg_cnt;2850 2851 sg = scsi_sglist(cmd);2852 2853 /* Setup packet address segment pointer. */2854 dword_ptr = (u32 *)&pkt->dseg_0_address;2855 2856 /* Load command entry data segments. */2857 for_each_sg(sg, s, seg_cnt, cnt) {2858 if (cnt == 2)2859 break;2860 2861 dma_handle = sg_dma_address(s);2862 *dword_ptr++ =2863 cpu_to_le32(lower_32_bits(dma_handle));2864 *dword_ptr++ =2865 cpu_to_le32(upper_32_bits(dma_handle));2866 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));2867 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",2868 cpu_to_le32(upper_32_bits(dma_handle)),2869 cpu_to_le32(lower_32_bits(dma_handle)),2870 cpu_to_le32(sg_dma_len(sg_next(s))));2871 remseg--;2872 }2873 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "2874 "command packet data - b %i, t %i, l %i \n",2875 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),2876 SCSI_LUN_32(cmd));2877 qla1280_dump_buffer(5, (char *)pkt,2878 REQUEST_ENTRY_SIZE);2879 2880 /*2881 * Build continuation packets.2882 */2883 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "2884 "remains\n", seg_cnt);2885 2886 while (remseg > 0) {2887 /* Update sg start */2888 sg = s;2889 /* Adjust ring index. */2890 ha->req_ring_index++;2891 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {2892 ha->req_ring_index = 0;2893 ha->request_ring_ptr =2894 ha->request_ring;2895 } else2896 ha->request_ring_ptr++;2897 2898 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;2899 2900 /* Zero out packet. */2901 memset(pkt, 0, REQUEST_ENTRY_SIZE);2902 2903 /* Load packet defaults. */2904 ((struct cont_a64_entry *) pkt)->entry_type =2905 CONTINUE_A64_TYPE;2906 ((struct cont_a64_entry *) pkt)->entry_count = 1;2907 ((struct cont_a64_entry *) pkt)->sys_define =2908 (uint8_t)ha->req_ring_index;2909 /* Setup packet address segment pointer. */2910 dword_ptr =2911 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;2912 2913 /* Load continuation entry data segments. */2914 for_each_sg(sg, s, remseg, cnt) {2915 if (cnt == 5)2916 break;2917 dma_handle = sg_dma_address(s);2918 *dword_ptr++ =2919 cpu_to_le32(lower_32_bits(dma_handle));2920 *dword_ptr++ =2921 cpu_to_le32(upper_32_bits(dma_handle));2922 *dword_ptr++ =2923 cpu_to_le32(sg_dma_len(s));2924 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",2925 cpu_to_le32(upper_32_bits(dma_handle)),2926 cpu_to_le32(lower_32_bits(dma_handle)),2927 cpu_to_le32(sg_dma_len(s)));2928 }2929 remseg -= cnt;2930 dprintk(5, "qla1280_64bit_start_scsi: "2931 "continuation packet data - b %i, t "2932 "%i, l %i \n", SCSI_BUS_32(cmd),2933 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));2934 qla1280_dump_buffer(5, (char *)pkt,2935 REQUEST_ENTRY_SIZE);2936 }2937 } else { /* No data transfer */2938 dprintk(5, "qla1280_64bit_start_scsi: No data, command "2939 "packet data - b %i, t %i, l %i \n",2940 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));2941 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);2942 }2943 /* Adjust ring index. */2944 ha->req_ring_index++;2945 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {2946 ha->req_ring_index = 0;2947 ha->request_ring_ptr = ha->request_ring;2948 } else2949 ha->request_ring_ptr++;2950 2951 /* Set chip new ring index. */2952 dprintk(2,2953 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");2954 sp->flags |= SRB_SENT;2955 ha->actthreads++;2956 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);2957 2958 out:2959 if (status)2960 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");2961 else2962 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");2963 2964 return status;2965}2966#else /* !QLA_64BIT_PTR */2967 2968/*2969 * qla1280_32bit_start_scsi2970 * The start SCSI is responsible for building request packets on2971 * request ring and modifying ISP input pointer.2972 *2973 * The Qlogic firmware interface allows every queue slot to have a SCSI2974 * command and up to 4 scatter/gather (SG) entries. If we need more2975 * than 4 SG entries, then continuation entries are used that can2976 * hold another 7 entries each. The start routine determines if there2977 * is eought empty slots then build the combination of requests to2978 * fulfill the OS request.2979 *2980 * Input:2981 * ha = adapter block pointer.2982 * sp = SCSI Request Block structure pointer.2983 *2984 * Returns:2985 * 0 = success, was able to issue command.2986 */2987static int2988qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)2989{2990 struct device_reg __iomem *reg = ha->iobase;2991 struct scsi_cmnd *cmd = sp->cmd;2992 struct cmd_entry *pkt;2993 __le32 *dword_ptr;2994 int status = 0;2995 int cnt;2996 int req_cnt;2997 int seg_cnt;2998 u8 dir;2999 3000 ENTER("qla1280_32bit_start_scsi");3001 3002 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,3003 cmd->cmnd[0]);3004 3005 /* Calculate number of entries and segments required. */3006 req_cnt = 1;3007 seg_cnt = scsi_dma_map(cmd);3008 if (seg_cnt) {3009 /*3010 * if greater than four sg entries then we need to allocate3011 * continuation entries3012 */3013 if (seg_cnt > 4) {3014 req_cnt += (seg_cnt - 4) / 7;3015 if ((seg_cnt - 4) % 7)3016 req_cnt++;3017 }3018 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",3019 cmd, seg_cnt, req_cnt);3020 } else if (seg_cnt < 0) {3021 status = 1;3022 goto out;3023 }3024 3025 if ((req_cnt + 2) >= ha->req_q_cnt) {3026 /* Calculate number of free request entries. */3027 cnt = RD_REG_WORD(®->mailbox4);3028 if (ha->req_ring_index < cnt)3029 ha->req_q_cnt = cnt - ha->req_ring_index;3030 else3031 ha->req_q_cnt =3032 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);3033 }3034 3035 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",3036 ha->req_q_cnt, seg_cnt);3037 /* If room for request in request ring. */3038 if ((req_cnt + 2) >= ha->req_q_cnt) {3039 status = SCSI_MLQUEUE_HOST_BUSY;3040 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "3041 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,3042 ha->req_q_cnt, req_cnt);3043 goto out;3044 }3045 3046 /* Check for empty slot in outstanding command list. */3047 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&3048 ha->outstanding_cmds[cnt]; cnt++);3049 3050 if (cnt >= MAX_OUTSTANDING_COMMANDS) {3051 status = SCSI_MLQUEUE_HOST_BUSY;3052 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "3053 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);3054 goto out;3055 }3056 3057 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);3058 ha->outstanding_cmds[cnt] = sp;3059 ha->req_q_cnt -= req_cnt;3060 3061 /*3062 * Build command packet.3063 */3064 pkt = (struct cmd_entry *) ha->request_ring_ptr;3065 3066 pkt->entry_type = COMMAND_TYPE;3067 pkt->entry_count = (uint8_t) req_cnt;3068 pkt->sys_define = (uint8_t) ha->req_ring_index;3069 pkt->entry_status = 0;3070 pkt->handle = cpu_to_le32(cnt);3071 3072 /* Zero out remaining portion of packet. */3073 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));3074 3075 /* Set ISP command timeout. */3076 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);3077 3078 /* Set device target ID and LUN */3079 pkt->lun = SCSI_LUN_32(cmd);3080 pkt->target = SCSI_BUS_32(cmd) ?3081 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);3082 3083 /* Enable simple tag queuing if device supports it. */3084 if (cmd->device->simple_tags)3085 pkt->control_flags |= cpu_to_le16(BIT_3);3086 3087 /* Load SCSI command packet. */3088 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));3089 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));3090 3091 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */3092 /* Set transfer direction. */3093 dir = qla1280_data_direction(cmd);3094 pkt->control_flags |= cpu_to_le16(dir);3095 3096 /* Set total data segment count. */3097 pkt->dseg_count = cpu_to_le16(seg_cnt);3098 3099 /*3100 * Load data segments.3101 */3102 if (seg_cnt) {3103 struct scatterlist *sg, *s;3104 int remseg = seg_cnt;3105 3106 sg = scsi_sglist(cmd);3107 3108 /* Setup packet address segment pointer. */3109 dword_ptr = &pkt->dseg_0_address;3110 3111 dprintk(3, "Building S/G data segments..\n");3112 qla1280_dump_buffer(1, (char *)sg, 4 * 16);3113 3114 /* Load command entry data segments. */3115 for_each_sg(sg, s, seg_cnt, cnt) {3116 if (cnt == 4)3117 break;3118 *dword_ptr++ =3119 cpu_to_le32(lower_32_bits(sg_dma_address(s)));3120 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));3121 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",3122 (lower_32_bits(sg_dma_address(s))),3123 (sg_dma_len(s)));3124 remseg--;3125 }3126 /*3127 * Build continuation packets.3128 */3129 dprintk(3, "S/G Building Continuation"3130 "...seg_cnt=0x%x remains\n", seg_cnt);3131 while (remseg > 0) {3132 /* Continue from end point */3133 sg = s;3134 /* Adjust ring index. */3135 ha->req_ring_index++;3136 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {3137 ha->req_ring_index = 0;3138 ha->request_ring_ptr =3139 ha->request_ring;3140 } else3141 ha->request_ring_ptr++;3142 3143 pkt = (struct cmd_entry *)ha->request_ring_ptr;3144 3145 /* Zero out packet. */3146 memset(pkt, 0, REQUEST_ENTRY_SIZE);3147 3148 /* Load packet defaults. */3149 ((struct cont_entry *) pkt)->3150 entry_type = CONTINUE_TYPE;3151 ((struct cont_entry *) pkt)->entry_count = 1;3152 3153 ((struct cont_entry *) pkt)->sys_define =3154 (uint8_t) ha->req_ring_index;3155 3156 /* Setup packet address segment pointer. */3157 dword_ptr =3158 &((struct cont_entry *) pkt)->dseg_0_address;3159 3160 /* Load continuation entry data segments. */3161 for_each_sg(sg, s, remseg, cnt) {3162 if (cnt == 7)3163 break;3164 *dword_ptr++ =3165 cpu_to_le32(lower_32_bits(sg_dma_address(s)));3166 *dword_ptr++ =3167 cpu_to_le32(sg_dma_len(s));3168 dprintk(1,3169 "S/G Segment Cont. phys_addr=0x%x, "3170 "len=0x%x\n",3171 cpu_to_le32(lower_32_bits(sg_dma_address(s))),3172 cpu_to_le32(sg_dma_len(s)));3173 }3174 remseg -= cnt;3175 dprintk(5, "qla1280_32bit_start_scsi: "3176 "continuation packet data - "3177 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),3178 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));3179 qla1280_dump_buffer(5, (char *)pkt,3180 REQUEST_ENTRY_SIZE);3181 }3182 } else { /* No data transfer at all */3183 dprintk(5, "qla1280_32bit_start_scsi: No data, command "3184 "packet data - \n");3185 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);3186 }3187 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");3188 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,3189 REQUEST_ENTRY_SIZE);3190 3191 /* Adjust ring index. */3192 ha->req_ring_index++;3193 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {3194 ha->req_ring_index = 0;3195 ha->request_ring_ptr = ha->request_ring;3196 } else3197 ha->request_ring_ptr++;3198 3199 /* Set chip new ring index. */3200 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "3201 "for pending command\n");3202 sp->flags |= SRB_SENT;3203 ha->actthreads++;3204 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);3205 3206out:3207 if (status)3208 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");3209 3210 LEAVE("qla1280_32bit_start_scsi");3211 3212 return status;3213}3214#endif3215 3216/*3217 * qla1280_req_pkt3218 * Function is responsible for locking ring and3219 * getting a zeroed out request packet.3220 *3221 * Input:3222 * ha = adapter block pointer.3223 *3224 * Returns:3225 * 0 = failed to get slot.3226 */3227static request_t *3228qla1280_req_pkt(struct scsi_qla_host *ha)3229{3230 struct device_reg __iomem *reg = ha->iobase;3231 request_t *pkt = NULL;3232 int cnt;3233 uint32_t timer;3234 3235 ENTER("qla1280_req_pkt");3236 3237 /*3238 * This can be called from interrupt context, damn it!!!3239 */3240 /* Wait for 30 seconds for slot. */3241 for (timer = 15000000; timer; timer--) {3242 if (ha->req_q_cnt > 0) {3243 /* Calculate number of free request entries. */3244 cnt = RD_REG_WORD(®->mailbox4);3245 if (ha->req_ring_index < cnt)3246 ha->req_q_cnt = cnt - ha->req_ring_index;3247 else3248 ha->req_q_cnt =3249 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);3250 }3251 3252 /* Found empty request ring slot? */3253 if (ha->req_q_cnt > 0) {3254 ha->req_q_cnt--;3255 pkt = ha->request_ring_ptr;3256 3257 /* Zero out packet. */3258 memset(pkt, 0, REQUEST_ENTRY_SIZE);3259 3260 /*3261 * How can this be right when we have a ring3262 * size of 512???3263 */3264 /* Set system defined field. */3265 pkt->sys_define = (uint8_t) ha->req_ring_index;3266 3267 /* Set entry count. */3268 pkt->entry_count = 1;3269 3270 break;3271 }3272 3273 udelay(2); /* 10 */3274 3275 /* Check for pending interrupts. */3276 qla1280_poll(ha);3277 }3278 3279 if (!pkt)3280 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");3281 else3282 dprintk(3, "qla1280_req_pkt: exiting normally\n");3283 3284 return pkt;3285}3286 3287/*3288 * qla1280_isp_cmd3289 * Function is responsible for modifying ISP input pointer.3290 * Releases ring lock.3291 *3292 * Input:3293 * ha = adapter block pointer.3294 */3295static void3296qla1280_isp_cmd(struct scsi_qla_host *ha)3297{3298 struct device_reg __iomem *reg = ha->iobase;3299 3300 ENTER("qla1280_isp_cmd");3301 3302 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");3303 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,3304 REQUEST_ENTRY_SIZE);3305 3306 /* Adjust ring index. */3307 ha->req_ring_index++;3308 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {3309 ha->req_ring_index = 0;3310 ha->request_ring_ptr = ha->request_ring;3311 } else3312 ha->request_ring_ptr++;3313 3314 /*3315 * Update request index to mailbox4 (Request Queue In).3316 */3317 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);3318 3319 LEAVE("qla1280_isp_cmd");3320}3321 3322/****************************************************************************/3323/* Interrupt Service Routine. */3324/****************************************************************************/3325 3326/****************************************************************************3327 * qla1280_isr3328 * Calls I/O done on command completion.3329 *3330 * Input:3331 * ha = adapter block pointer.3332 * done_q = done queue.3333 ****************************************************************************/3334static void3335qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)3336{3337 struct device_reg __iomem *reg = ha->iobase;3338 struct response *pkt;3339 struct srb *sp = NULL;3340 uint16_t mailbox[MAILBOX_REGISTER_COUNT];3341 uint16_t *wptr;3342 uint32_t index;3343 u16 istatus;3344 3345 ENTER("qla1280_isr");3346 3347 istatus = RD_REG_WORD(®->istatus);3348 if (!(istatus & (RISC_INT | PCI_INT)))3349 return;3350 3351 /* Save mailbox register 5 */3352 mailbox[5] = RD_REG_WORD(®->mailbox5);3353 3354 /* Check for mailbox interrupt. */3355 3356 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);3357 3358 if (mailbox[0] & BIT_0) {3359 /* Get mailbox data. */3360 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */3361 3362 wptr = &mailbox[0];3363 *wptr++ = RD_REG_WORD(®->mailbox0);3364 *wptr++ = RD_REG_WORD(®->mailbox1);3365 *wptr = RD_REG_WORD(®->mailbox2);3366 if (mailbox[0] != MBA_SCSI_COMPLETION) {3367 wptr++;3368 *wptr++ = RD_REG_WORD(®->mailbox3);3369 *wptr++ = RD_REG_WORD(®->mailbox4);3370 wptr++;3371 *wptr++ = RD_REG_WORD(®->mailbox6);3372 *wptr = RD_REG_WORD(®->mailbox7);3373 }3374 3375 /* Release mailbox registers. */3376 3377 WRT_REG_WORD(®->semaphore, 0);3378 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);3379 3380 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",3381 mailbox[0]);3382 3383 /* Handle asynchronous event */3384 switch (mailbox[0]) {3385 case MBA_SCSI_COMPLETION: /* Response completion */3386 dprintk(5, "qla1280_isr: mailbox SCSI response "3387 "completion\n");3388 3389 if (ha->flags.online) {3390 /* Get outstanding command index. */3391 index = mailbox[2] << 16 | mailbox[1];3392 3393 /* Validate handle. */3394 if (index < MAX_OUTSTANDING_COMMANDS)3395 sp = ha->outstanding_cmds[index];3396 else3397 sp = NULL;3398 3399 if (sp) {3400 /* Free outstanding command slot. */3401 ha->outstanding_cmds[index] = NULL;3402 3403 /* Save ISP completion status */3404 CMD_RESULT(sp->cmd) = 0;3405 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;3406 3407 /* Place block on done queue */3408 list_add_tail(&sp->list, done_q);3409 } else {3410 /*3411 * If we get here we have a real problem!3412 */3413 printk(KERN_WARNING3414 "qla1280: ISP invalid handle\n");3415 }3416 }3417 break;3418 3419 case MBA_BUS_RESET: /* SCSI Bus Reset */3420 ha->flags.reset_marker = 1;3421 index = mailbox[6] & BIT_0;3422 ha->bus_settings[index].reset_marker = 1;3423 3424 printk(KERN_DEBUG "qla1280_isr(): index %i "3425 "asynchronous BUS_RESET\n", index);3426 break;3427 3428 case MBA_SYSTEM_ERR: /* System Error */3429 printk(KERN_WARNING3430 "qla1280: ISP System Error - mbx1=%xh, mbx2="3431 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],3432 mailbox[3]);3433 break;3434 3435 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */3436 printk(KERN_WARNING3437 "qla1280: ISP Request Transfer Error\n");3438 break;3439 3440 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */3441 printk(KERN_WARNING3442 "qla1280: ISP Response Transfer Error\n");3443 break;3444 3445 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */3446 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");3447 break;3448 3449 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */3450 dprintk(2,3451 "qla1280_isr: asynchronous TIMEOUT_RESET\n");3452 break;3453 3454 case MBA_DEVICE_RESET: /* Bus Device Reset */3455 printk(KERN_INFO "qla1280_isr(): asynchronous "3456 "BUS_DEVICE_RESET\n");3457 3458 ha->flags.reset_marker = 1;3459 index = mailbox[6] & BIT_0;3460 ha->bus_settings[index].reset_marker = 1;3461 break;3462 3463 case MBA_BUS_MODE_CHANGE:3464 dprintk(2,3465 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");3466 break;3467 3468 default:3469 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */3470 if (mailbox[0] < MBA_ASYNC_EVENT) {3471 wptr = &mailbox[0];3472 memcpy((uint16_t *) ha->mailbox_out, wptr,3473 MAILBOX_REGISTER_COUNT *3474 sizeof(uint16_t));3475 3476 if(ha->mailbox_wait != NULL)3477 complete(ha->mailbox_wait);3478 }3479 break;3480 }3481 } else {3482 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);3483 }3484 3485 /*3486 * We will receive interrupts during mailbox testing prior to3487 * the card being marked online, hence the double check.3488 */3489 if (!(ha->flags.online && !ha->mailbox_wait)) {3490 dprintk(2, "qla1280_isr: Response pointer Error\n");3491 goto out;3492 }3493 3494 if (mailbox[5] >= RESPONSE_ENTRY_CNT)3495 goto out;3496 3497 while (ha->rsp_ring_index != mailbox[5]) {3498 pkt = ha->response_ring_ptr;3499 3500 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"3501 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);3502 dprintk(5,"qla1280_isr: response packet data\n");3503 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);3504 3505 if (pkt->entry_type == STATUS_TYPE) {3506 if ((le16_to_cpu(pkt->scsi_status) & 0xff)3507 || pkt->comp_status || pkt->entry_status) {3508 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "3509 "0x%x mailbox[5] = 0x%x, comp_status "3510 "= 0x%x, scsi_status = 0x%x\n",3511 ha->rsp_ring_index, mailbox[5],3512 le16_to_cpu(pkt->comp_status),3513 le16_to_cpu(pkt->scsi_status));3514 }3515 } else {3516 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "3517 "0x%x, mailbox[5] = 0x%x\n",3518 ha->rsp_ring_index, mailbox[5]);3519 dprintk(2, "qla1280_isr: response packet data\n");3520 qla1280_dump_buffer(2, (char *)pkt,3521 RESPONSE_ENTRY_SIZE);3522 }3523 3524 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {3525 dprintk(2, "status: Cmd %p, handle %i\n",3526 ha->outstanding_cmds[pkt->handle]->cmd,3527 pkt->handle);3528 if (pkt->entry_type == STATUS_TYPE)3529 qla1280_status_entry(ha, pkt, done_q);3530 else3531 qla1280_error_entry(ha, pkt, done_q);3532 /* Adjust ring index. */3533 ha->rsp_ring_index++;3534 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {3535 ha->rsp_ring_index = 0;3536 ha->response_ring_ptr = ha->response_ring;3537 } else3538 ha->response_ring_ptr++;3539 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);3540 }3541 }3542 3543 out:3544 LEAVE("qla1280_isr");3545}3546 3547/*3548 * qla1280_rst_aen3549 * Processes asynchronous reset.3550 *3551 * Input:3552 * ha = adapter block pointer.3553 */3554static void3555qla1280_rst_aen(struct scsi_qla_host *ha)3556{3557 uint8_t bus;3558 3559 ENTER("qla1280_rst_aen");3560 3561 if (ha->flags.online && !ha->flags.reset_active &&3562 !ha->flags.abort_isp_active) {3563 ha->flags.reset_active = 1;3564 while (ha->flags.reset_marker) {3565 /* Issue marker command. */3566 ha->flags.reset_marker = 0;3567 for (bus = 0; bus < ha->ports &&3568 !ha->flags.reset_marker; bus++) {3569 if (ha->bus_settings[bus].reset_marker) {3570 ha->bus_settings[bus].reset_marker = 0;3571 qla1280_marker(ha, bus, 0, 0,3572 MK_SYNC_ALL);3573 }3574 }3575 }3576 }3577 3578 LEAVE("qla1280_rst_aen");3579}3580 3581 3582/*3583 * qla1280_status_entry3584 * Processes received ISP status entry.3585 *3586 * Input:3587 * ha = adapter block pointer.3588 * pkt = entry pointer.3589 * done_q = done queue.3590 */3591static void3592qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,3593 struct list_head *done_q)3594{3595 int sense_sz;3596 struct srb *sp;3597 struct scsi_cmnd *cmd;3598 uint32_t handle = le32_to_cpu(pkt->handle);3599 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);3600 uint16_t comp_status = le16_to_cpu(pkt->comp_status);3601 3602 ENTER("qla1280_status_entry");3603 3604 /* Validate handle. */3605 if (handle < MAX_OUTSTANDING_COMMANDS)3606 sp = ha->outstanding_cmds[handle];3607 else3608 sp = NULL;3609 3610 if (!sp) {3611 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");3612 goto out;3613 }3614 3615 /* Free outstanding command slot. */3616 ha->outstanding_cmds[handle] = NULL;3617 3618 cmd = sp->cmd;3619 3620 if (comp_status || scsi_status) {3621 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "3622 "0x%x, handle = 0x%x\n", comp_status,3623 scsi_status, handle);3624 }3625 3626 /* Target busy or queue full */3627 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||3628 (scsi_status & 0xFF) == SAM_STAT_BUSY) {3629 CMD_RESULT(cmd) = scsi_status & 0xff;3630 } else {3631 3632 /* Save ISP completion status */3633 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);3634 3635 if (scsi_status & SAM_STAT_CHECK_CONDITION) {3636 if (comp_status != CS_ARS_FAILED) {3637 uint16_t req_sense_length =3638 le16_to_cpu(pkt->req_sense_length);3639 if (req_sense_length < CMD_SNSLEN(cmd))3640 sense_sz = req_sense_length;3641 else3642 /*3643 * scsi_cmnd->sense_buffer is3644 * 64 bytes, why only copy 63?3645 * This looks wrong! /Jes3646 */3647 sense_sz = CMD_SNSLEN(cmd) - 1;3648 3649 memcpy(cmd->sense_buffer,3650 &pkt->req_sense_data, sense_sz);3651 } else3652 sense_sz = 0;3653 memset(cmd->sense_buffer + sense_sz, 0,3654 SCSI_SENSE_BUFFERSIZE - sense_sz);3655 3656 dprintk(2, "qla1280_status_entry: Check "3657 "condition Sense data, b %i, t %i, "3658 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),3659 SCSI_LUN_32(cmd));3660 if (sense_sz)3661 qla1280_dump_buffer(2,3662 (char *)cmd->sense_buffer,3663 sense_sz);3664 }3665 }3666 3667 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;3668 3669 /* Place command on done queue. */3670 list_add_tail(&sp->list, done_q);3671 out:3672 LEAVE("qla1280_status_entry");3673}3674 3675/*3676 * qla1280_error_entry3677 * Processes error entry.3678 *3679 * Input:3680 * ha = adapter block pointer.3681 * pkt = entry pointer.3682 * done_q = done queue.3683 */3684static void3685qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,3686 struct list_head *done_q)3687{3688 struct srb *sp;3689 uint32_t handle = le32_to_cpu(pkt->handle);3690 3691 ENTER("qla1280_error_entry");3692 3693 if (pkt->entry_status & BIT_3)3694 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");3695 else if (pkt->entry_status & BIT_2)3696 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");3697 else if (pkt->entry_status & BIT_1)3698 dprintk(2, "qla1280_error_entry: FULL flag error\n");3699 else3700 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");3701 3702 /* Validate handle. */3703 if (handle < MAX_OUTSTANDING_COMMANDS)3704 sp = ha->outstanding_cmds[handle];3705 else3706 sp = NULL;3707 3708 if (sp) {3709 /* Free outstanding command slot. */3710 ha->outstanding_cmds[handle] = NULL;3711 3712 /* Bad payload or header */3713 if (pkt->entry_status & (BIT_3 + BIT_2)) {3714 /* Bad payload or header, set error status. */3715 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */3716 CMD_RESULT(sp->cmd) = DID_ERROR << 16;3717 } else if (pkt->entry_status & BIT_1) { /* FULL flag */3718 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;3719 } else {3720 /* Set error status. */3721 CMD_RESULT(sp->cmd) = DID_ERROR << 16;3722 }3723 3724 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;3725 3726 /* Place command on done queue. */3727 list_add_tail(&sp->list, done_q);3728 }3729#ifdef QLA_64BIT_PTR3730 else if (pkt->entry_type == COMMAND_A64_TYPE) {3731 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");3732 }3733#endif3734 3735 LEAVE("qla1280_error_entry");3736}3737 3738/*3739 * qla1280_abort_isp3740 * Resets ISP and aborts all outstanding commands.3741 *3742 * Input:3743 * ha = adapter block pointer.3744 *3745 * Returns:3746 * 0 = success3747 */3748static int3749qla1280_abort_isp(struct scsi_qla_host *ha)3750{3751 struct device_reg __iomem *reg = ha->iobase;3752 struct srb *sp;3753 int status = 0;3754 int cnt;3755 int bus;3756 3757 ENTER("qla1280_abort_isp");3758 3759 if (ha->flags.abort_isp_active || !ha->flags.online)3760 goto out;3761 3762 ha->flags.abort_isp_active = 1;3763 3764 /* Disable ISP interrupts. */3765 qla1280_disable_intrs(ha);3766 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);3767 RD_REG_WORD(®->id_l);3768 3769 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",3770 ha->host_no);3771 /* Dequeue all commands in outstanding command list. */3772 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {3773 struct scsi_cmnd *cmd;3774 sp = ha->outstanding_cmds[cnt];3775 if (sp) {3776 cmd = sp->cmd;3777 CMD_RESULT(cmd) = DID_RESET << 16;3778 CMD_HANDLE(cmd) = COMPLETED_HANDLE;3779 ha->outstanding_cmds[cnt] = NULL;3780 list_add_tail(&sp->list, &ha->done_q);3781 }3782 }3783 3784 qla1280_done(ha);3785 3786 status = qla1280_load_firmware(ha);3787 if (status)3788 goto out;3789 3790 /* Setup adapter based on NVRAM parameters. */3791 qla1280_nvram_config (ha);3792 3793 status = qla1280_init_rings(ha);3794 if (status)3795 goto out;3796 3797 /* Issue SCSI reset. */3798 for (bus = 0; bus < ha->ports; bus++)3799 qla1280_bus_reset(ha, bus);3800 3801 ha->flags.abort_isp_active = 0;3802 out:3803 if (status) {3804 printk(KERN_WARNING3805 "qla1280: ISP error recovery failed, board disabled");3806 qla1280_reset_adapter(ha);3807 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");3808 }3809 3810 LEAVE("qla1280_abort_isp");3811 return status;3812}3813 3814 3815/*3816 * qla1280_debounce_register3817 * Debounce register.3818 *3819 * Input:3820 * port = register address.3821 *3822 * Returns:3823 * register value.3824 */3825static u163826qla1280_debounce_register(volatile u16 __iomem * addr)3827{3828 volatile u16 ret;3829 volatile u16 ret2;3830 3831 ret = RD_REG_WORD(addr);3832 ret2 = RD_REG_WORD(addr);3833 3834 if (ret == ret2)3835 return ret;3836 3837 do {3838 cpu_relax();3839 ret = RD_REG_WORD(addr);3840 ret2 = RD_REG_WORD(addr);3841 } while (ret != ret2);3842 3843 return ret;3844}3845 3846 3847/************************************************************************3848 * qla1280_check_for_dead_scsi_bus *3849 * *3850 * This routine checks for a dead SCSI bus *3851 ************************************************************************/3852#define SET_SXP_BANK 0x01003853#define SCSI_PHASE_INVALID 0x87FF3854static int3855qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)3856{3857 uint16_t config_reg, scsi_control;3858 struct device_reg __iomem *reg = ha->iobase;3859 3860 if (ha->bus_settings[bus].scsi_bus_dead) {3861 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);3862 config_reg = RD_REG_WORD(®->cfg_1);3863 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);3864 scsi_control = RD_REG_WORD(®->scsiControlPins);3865 WRT_REG_WORD(®->cfg_1, config_reg);3866 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);3867 3868 if (scsi_control == SCSI_PHASE_INVALID) {3869 ha->bus_settings[bus].scsi_bus_dead = 1;3870 return 1; /* bus is dead */3871 } else {3872 ha->bus_settings[bus].scsi_bus_dead = 0;3873 ha->bus_settings[bus].failed_reset_count = 0;3874 }3875 }3876 return 0; /* bus is not dead */3877}3878 3879static void3880qla1280_get_target_parameters(struct scsi_qla_host *ha,3881 struct scsi_device *device)3882{3883 uint16_t mb[MAILBOX_REGISTER_COUNT];3884 int bus, target, lun;3885 3886 bus = device->channel;3887 target = device->id;3888 lun = device->lun;3889 3890 3891 mb[0] = MBC_GET_TARGET_PARAMETERS;3892 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);3893 mb[1] <<= 8;3894 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,3895 &mb[0]);3896 3897 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);3898 3899 if (mb[3] != 0) {3900 printk(KERN_CONT " Sync: period %d, offset %d",3901 (mb[3] & 0xff), (mb[3] >> 8));3902 if (mb[2] & BIT_13)3903 printk(KERN_CONT ", Wide");3904 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)3905 printk(KERN_CONT ", DT");3906 } else3907 printk(KERN_CONT " Async");3908 3909 if (device->simple_tags)3910 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);3911 printk(KERN_CONT "\n");3912}3913 3914 3915#if DEBUG_QLA12803916static void3917__qla1280_dump_buffer(char *b, int size)3918{3919 int cnt;3920 u8 c;3921 3922 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "3923 "Bh Ch Dh Eh Fh\n");3924 printk(KERN_DEBUG "---------------------------------------------"3925 "------------------\n");3926 3927 for (cnt = 0; cnt < size;) {3928 c = *b++;3929 3930 printk("0x%02x", c);3931 cnt++;3932 if (!(cnt % 16))3933 printk("\n");3934 else3935 printk(" ");3936 }3937 if (cnt % 16)3938 printk("\n");3939}3940 3941/**************************************************************************3942 * ql1280_print_scsi_cmd3943 *3944 **************************************************************************/3945static void3946__qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)3947{3948 struct scsi_qla_host *ha;3949 struct Scsi_Host *host = CMD_HOST(cmd);3950 struct srb *sp;3951 /* struct scatterlist *sg; */3952 3953 int i;3954 ha = (struct scsi_qla_host *)host->hostdata;3955 3956 sp = scsi_cmd_priv(cmd);3957 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));3958 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",3959 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),3960 CMD_CDBLEN(cmd));3961 printk(" CDB = ");3962 for (i = 0; i < cmd->cmd_len; i++) {3963 printk("0x%02x ", cmd->cmnd[i]);3964 }3965 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));3966 printk(" request buffer=0x%p, request buffer len=0x%x\n",3967 scsi_sglist(cmd), scsi_bufflen(cmd));3968 /* if (cmd->use_sg)3969 {3970 sg = (struct scatterlist *) cmd->request_buffer;3971 printk(" SG buffer: \n");3972 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));3973 } */3974 printk(" tag=%d, transfersize=0x%x \n",3975 scsi_cmd_to_rq(cmd)->tag, cmd->transfersize);3976 printk(" underflow size = 0x%x, direction=0x%x\n",3977 cmd->underflow, cmd->sc_data_direction);3978}3979 3980/**************************************************************************3981 * ql1280_dump_device3982 *3983 **************************************************************************/3984static void3985ql1280_dump_device(struct scsi_qla_host *ha)3986{3987 3988 struct scsi_cmnd *cp;3989 struct srb *sp;3990 int i;3991 3992 printk(KERN_DEBUG "Outstanding Commands on controller:\n");3993 3994 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {3995 if ((sp = ha->outstanding_cmds[i]) == NULL)3996 continue;3997 if ((cp = sp->cmd) == NULL)3998 continue;3999 qla1280_print_scsi_cmd(1, cp);4000 }4001}4002#endif4003 4004 4005enum tokens {4006 TOKEN_NVRAM,4007 TOKEN_SYNC,4008 TOKEN_WIDE,4009 TOKEN_PPR,4010 TOKEN_VERBOSE,4011 TOKEN_DEBUG,4012};4013 4014struct setup_tokens {4015 char *token;4016 int val;4017};4018 4019static struct setup_tokens setup_token[] __initdata = 4020{4021 { "nvram", TOKEN_NVRAM },4022 { "sync", TOKEN_SYNC },4023 { "wide", TOKEN_WIDE },4024 { "ppr", TOKEN_PPR },4025 { "verbose", TOKEN_VERBOSE },4026 { "debug", TOKEN_DEBUG },4027};4028 4029 4030/**************************************************************************4031 * qla1280_setup4032 *4033 * Handle boot parameters. This really needs to be changed so one4034 * can specify per adapter parameters.4035 **************************************************************************/4036static int __init4037qla1280_setup(char *s)4038{4039 char *cp, *ptr;4040 unsigned long val;4041 4042 cp = s;4043 4044 while (cp && (ptr = strchr(cp, ':'))) {4045 ptr++;4046 if (!strcmp(ptr, "yes")) {4047 val = 0x10000;4048 ptr += 3;4049 } else if (!strcmp(ptr, "no")) {4050 val = 0;4051 ptr += 2;4052 } else4053 val = simple_strtoul(ptr, &ptr, 0);4054 4055 switch (qla1280_get_token(cp)) {4056 case TOKEN_NVRAM:4057 if (!val)4058 driver_setup.no_nvram = 1;4059 break;4060 case TOKEN_SYNC:4061 if (!val)4062 driver_setup.no_sync = 1;4063 else if (val != 0x10000)4064 driver_setup.sync_mask = val;4065 break;4066 case TOKEN_WIDE:4067 if (!val)4068 driver_setup.no_wide = 1;4069 else if (val != 0x10000)4070 driver_setup.wide_mask = val;4071 break;4072 case TOKEN_PPR:4073 if (!val)4074 driver_setup.no_ppr = 1;4075 else if (val != 0x10000)4076 driver_setup.ppr_mask = val;4077 break;4078 case TOKEN_VERBOSE:4079 qla1280_verbose = val;4080 break;4081 default:4082 printk(KERN_INFO "qla1280: unknown boot option %s\n",4083 cp);4084 }4085 4086 cp = strchr(ptr, ';');4087 if (cp)4088 cp++;4089 else {4090 break;4091 }4092 }4093 return 1;4094}4095 4096 4097static int __init4098qla1280_get_token(char *str)4099{4100 char *sep;4101 long ret = -1;4102 int i;4103 4104 sep = strchr(str, ':');4105 4106 if (sep) {4107 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {4108 if (!strncmp(setup_token[i].token, str, (sep - str))) {4109 ret = setup_token[i].val;4110 break;4111 }4112 }4113 }4114 4115 return ret;4116}4117 4118 4119static const struct scsi_host_template qla1280_driver_template = {4120 .module = THIS_MODULE,4121 .proc_name = "qla1280",4122 .name = "Qlogic ISP 1280/12160",4123 .info = qla1280_info,4124 .slave_configure = qla1280_slave_configure,4125 .queuecommand = qla1280_queuecommand,4126 .eh_abort_handler = qla1280_eh_abort,4127 .eh_device_reset_handler= qla1280_eh_device_reset,4128 .eh_bus_reset_handler = qla1280_eh_bus_reset,4129 .eh_host_reset_handler = qla1280_eh_adapter_reset,4130 .bios_param = qla1280_biosparam,4131 .can_queue = MAX_OUTSTANDING_COMMANDS,4132 .this_id = -1,4133 .sg_tablesize = SG_ALL,4134 .cmd_size = sizeof(struct srb),4135};4136 4137 4138static int4139qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)4140{4141 int devnum = id->driver_data;4142 struct qla_boards *bdp = &ql1280_board_tbl[devnum];4143 struct Scsi_Host *host;4144 struct scsi_qla_host *ha;4145 int error = -ENODEV;4146 4147 /* Bypass all AMI SUBSYS VENDOR IDs */4148 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {4149 printk(KERN_INFO4150 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");4151 goto error;4152 }4153 4154 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",4155 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));4156 4157 if (pci_enable_device(pdev)) {4158 printk(KERN_WARNING4159 "qla1280: Failed to enabled pci device, aborting.\n");4160 goto error;4161 }4162 4163 pci_set_master(pdev);4164 4165 error = -ENOMEM;4166 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));4167 if (!host) {4168 printk(KERN_WARNING4169 "qla1280: Failed to register host, aborting.\n");4170 goto error_disable_device;4171 }4172 4173 ha = (struct scsi_qla_host *)host->hostdata;4174 memset(ha, 0, sizeof(struct scsi_qla_host));4175 4176 ha->pdev = pdev;4177 ha->devnum = devnum; /* specifies microcode load address */4178 4179#ifdef QLA_64BIT_PTR4180 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {4181 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {4182 printk(KERN_WARNING "scsi(%li): Unable to set a "4183 "suitable DMA mask - aborting\n", ha->host_no);4184 error = -ENODEV;4185 goto error_put_host;4186 }4187 } else4188 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",4189 ha->host_no);4190#else4191 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {4192 printk(KERN_WARNING "scsi(%li): Unable to set a "4193 "suitable DMA mask - aborting\n", ha->host_no);4194 error = -ENODEV;4195 goto error_put_host;4196 }4197#endif4198 4199 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,4200 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),4201 &ha->request_dma, GFP_KERNEL);4202 if (!ha->request_ring) {4203 printk(KERN_INFO "qla1280: Failed to get request memory\n");4204 goto error_put_host;4205 }4206 4207 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,4208 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),4209 &ha->response_dma, GFP_KERNEL);4210 if (!ha->response_ring) {4211 printk(KERN_INFO "qla1280: Failed to get response memory\n");4212 goto error_free_request_ring;4213 }4214 4215 ha->ports = bdp->numPorts;4216 4217 ha->host = host;4218 ha->host_no = host->host_no;4219 4220 host->irq = pdev->irq;4221 host->max_channel = bdp->numPorts - 1;4222 host->max_lun = MAX_LUNS - 1;4223 host->max_id = MAX_TARGETS;4224 host->max_sectors = 1024;4225 host->unique_id = host->host_no;4226 4227 error = -ENODEV;4228 4229#if MEMORY_MAPPED_IO4230 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);4231 if (!ha->mmpbase) {4232 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");4233 goto error_free_response_ring;4234 }4235 4236 host->base = (unsigned long)ha->mmpbase;4237 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;4238#else4239 host->io_port = pci_resource_start(ha->pdev, 0);4240 if (!request_region(host->io_port, 0xff, "qla1280")) {4241 printk(KERN_INFO "qla1280: Failed to reserve i/o region "4242 "0x%04lx-0x%04lx - already in use\n",4243 host->io_port, host->io_port + 0xff);4244 goto error_free_response_ring;4245 }4246 4247 ha->iobase = (struct device_reg *)host->io_port;4248#endif4249 4250 INIT_LIST_HEAD(&ha->done_q);4251 4252 /* Disable ISP interrupts. */4253 qla1280_disable_intrs(ha);4254 4255 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,4256 "qla1280", ha)) {4257 printk("qla1280 : Failed to reserve interrupt %d already "4258 "in use\n", pdev->irq);4259 goto error_release_region;4260 }4261 4262 /* load the F/W, read paramaters, and init the H/W */4263 if (qla1280_initialize_adapter(ha)) {4264 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");4265 goto error_free_irq;4266 }4267 4268 /* set our host ID (need to do something about our two IDs) */4269 host->this_id = ha->bus_settings[0].id;4270 4271 pci_set_drvdata(pdev, host);4272 4273 error = scsi_add_host(host, &pdev->dev);4274 if (error)4275 goto error_disable_adapter;4276 scsi_scan_host(host);4277 4278 return 0;4279 4280 error_disable_adapter:4281 qla1280_disable_intrs(ha);4282 error_free_irq:4283 free_irq(pdev->irq, ha);4284 error_release_region:4285#if MEMORY_MAPPED_IO4286 iounmap(ha->mmpbase);4287#else4288 release_region(host->io_port, 0xff);4289#endif4290 error_free_response_ring:4291 dma_free_coherent(&ha->pdev->dev,4292 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),4293 ha->response_ring, ha->response_dma);4294 error_free_request_ring:4295 dma_free_coherent(&ha->pdev->dev,4296 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),4297 ha->request_ring, ha->request_dma);4298 error_put_host:4299 scsi_host_put(host);4300 error_disable_device:4301 pci_disable_device(pdev);4302 error:4303 return error;4304}4305 4306 4307static void4308qla1280_remove_one(struct pci_dev *pdev)4309{4310 struct Scsi_Host *host = pci_get_drvdata(pdev);4311 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;4312 4313 scsi_remove_host(host);4314 4315 qla1280_disable_intrs(ha);4316 4317 free_irq(pdev->irq, ha);4318 4319#if MEMORY_MAPPED_IO4320 iounmap(ha->mmpbase);4321#else4322 release_region(host->io_port, 0xff);4323#endif4324 4325 dma_free_coherent(&ha->pdev->dev,4326 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),4327 ha->request_ring, ha->request_dma);4328 dma_free_coherent(&ha->pdev->dev,4329 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),4330 ha->response_ring, ha->response_dma);4331 4332 pci_disable_device(pdev);4333 4334 scsi_host_put(host);4335}4336 4337static struct pci_driver qla1280_pci_driver = {4338 .name = "qla1280",4339 .id_table = qla1280_pci_tbl,4340 .probe = qla1280_probe_one,4341 .remove = qla1280_remove_one,4342};4343 4344static int __init4345qla1280_init(void)4346{4347#ifdef MODULE4348 /*4349 * If we are called as a module, the qla1280 pointer may not be null4350 * and it would point to our bootup string, just like on the lilo4351 * command line. IF not NULL, then process this config string with4352 * qla1280_setup4353 *4354 * Boot time Options4355 * To add options at boot time add a line to your lilo.conf file like:4356 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"4357 * which will result in the first four devices on the first two4358 * controllers being set to a tagged queue depth of 32.4359 */4360 if (qla1280)4361 qla1280_setup(qla1280);4362#endif4363 4364 return pci_register_driver(&qla1280_pci_driver);4365}4366 4367static void __exit4368qla1280_exit(void)4369{4370 int i;4371 4372 pci_unregister_driver(&qla1280_pci_driver);4373 /* release any allocated firmware images */4374 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {4375 release_firmware(qla1280_fw_tbl[i].fw);4376 qla1280_fw_tbl[i].fw = NULL;4377 }4378}4379 4380module_init(qla1280_init);4381module_exit(qla1280_exit);4382 4383MODULE_AUTHOR("Qlogic & Jes Sorensen");4384MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");4385MODULE_LICENSE("GPL");4386MODULE_FIRMWARE("qlogic/1040.bin");4387MODULE_FIRMWARE("qlogic/1280.bin");4388MODULE_FIRMWARE("qlogic/12160.bin");4389MODULE_VERSION(QLA1280_VERSION);4390