1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /******************************************************************************
3 * QLOGIC LINUX SOFTWARE
5 * QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver
6 * 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 Hellwig
10 ******************************************************************************/
11 #define QLA1280_VERSION "3.27.1"
12 /*****************************************************************************
14 Rev 3.27.1, February 8, 2010, Michael Reed
15 - Retain firmware image for error recovery.
16 Rev 3.27, February 10, 2009, Michael Reed
17 - General code cleanup.
18 - Improve error recovery.
19 Rev 3.26, January 16, 2006 Jes Sorensen
20 - Ditch all < 2.6 support
21 Rev 3.25.1, February 10, 2005 Christoph Hellwig
22 - use pci_map_single to map non-S/G requests
23 - remove qla1280_proc_info
24 Rev 3.25, September 28, 2004, Christoph Hellwig
25 - add support for ISP1020/1040
26 - don't include "scsi.h" anymore for 2.6.x
27 Rev 3.24.4 June 7, 2004 Christoph Hellwig
28 - restructure firmware loading, cleanup initialization code
29 - prepare support for ISP1020/1040 chips
30 Rev 3.24.3 January 19, 2004, Jes Sorensen
31 - Handle PCI DMA mask settings correctly
32 - Correct order of error handling in probe_one, free_irq should not
33 be called if request_irq failed
34 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
35 - Big endian fixes (James)
36 - Remove bogus IOCB content on zero data transfer commands (Andrew)
37 Rev 3.24.1 January 5, 2004, Jes Sorensen
38 - Initialize completion queue to avoid OOPS on probe
39 - Handle interrupts during mailbox testing
40 Rev 3.24 November 17, 2003, Christoph Hellwig
41 - use struct list_head for completion queue
42 - avoid old Scsi_FOO typedefs
43 - cleanup 2.4 compat glue a bit
44 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
45 - make initialization for memory mapped vs port I/O more similar
46 - remove broken pci config space manipulation
48 - this is an almost perfect 2.6 scsi driver now! ;)
49 Rev 3.23.39 December 17, 2003, Jes Sorensen
50 - Delete completion queue from srb if mailbox command failed to
51 to avoid qla1280_done completeting qla1280_error_action's
53 - Reduce arguments for qla1280_done
54 Rev 3.23.38 October 18, 2003, Christoph Hellwig
55 - Convert to new-style hotplugable driver for 2.6
56 - Fix missing scsi_unregister/scsi_host_put on HBA removal
57 - Kill some more cruft
58 Rev 3.23.37 October 1, 2003, Jes Sorensen
59 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
61 - Clean up locking in probe path
62 Rev 3.23.36 October 1, 2003, Christoph Hellwig
63 - queuecommand only ever receives new commands - clear flags
64 - Reintegrate lost fixes from Linux 2.5
65 Rev 3.23.35 August 14, 2003, Jes Sorensen
67 Rev 3.23.34 July 23, 2003, Jes Sorensen
68 - Remove pointless TRUE/FALSE macros
69 - Clean up vchan handling
70 Rev 3.23.33 July 3, 2003, Jes Sorensen
71 - 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 as
74 it won't respond and causes an MCA
75 Rev 3.23.32 June 23, 2003, Jes Sorensen
76 - Basic support for boot time arguments
77 Rev 3.23.31 June 8, 2003, Jes Sorensen
78 - Reduce boot time messages
79 Rev 3.23.30 June 6, 2003, Jes Sorensen
80 - Do not enable sync/wide/ppr before it has been determined
81 that the target device actually supports it
82 - Enable DMA arbitration for multi channel controllers
83 Rev 3.23.29 June 3, 2003, Jes Sorensen
85 Rev 3.23.28 June 3, 2003, Jes Sorensen
86 - Eliminate duplicate marker commands on bus resets
87 - Handle outstanding commands appropriately on bus/device resets
88 Rev 3.23.27 May 28, 2003, Jes Sorensen
89 - Remove bogus input queue code, let the Linux SCSI layer do the work
90 - Clean up NVRAM handling, only read it once from the card
91 - Add a number of missing default nvram parameters
92 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
93 - Use completion queue for mailbox commands instead of busy wait
94 Rev 3.23.25 Beta May 27, 2003, James Bottomley
95 - Migrate to use new error handling code
96 Rev 3.23.24 Beta May 21, 2003, James Bottomley
98 - Cleanup data direction code
99 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
100 - Switch to using MMIO instead of PIO
101 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
102 - Fix PCI parity problem with 12160 during reset.
103 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
104 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
105 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
106 - Remove < 2.4.x support
107 - Introduce HOST_LOCK to make the spin lock changes portable.
108 - Remove a bunch of idiotic and unnecessary typedef's
109 - Kill all leftovers of target-mode support which never worked anyway
110 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
111 - Do qla1280_pci_config() before calling request_irq() and
113 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
115 - Hand correct arguments to free_irq() in case of failure
116 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
117 - Run source through Lindent and clean up the output
118 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
119 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
120 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
121 - Rely on mailbox commands generating interrupts - do not
122 run qla1280_isr() from ql1280_mailbox_command()
123 - Remove device_reg_t
124 - Integrate ql12160_set_target_parameters() with 1280 version
125 - Make qla1280_setup() non static
126 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
127 sent to the card - this command pauses the firmware!!!
128 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
129 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
130 - Remove a pile of pointless and confusing (srb_t **) and
131 (scsi_lu_t *) typecasts
132 - Explicit mark that we do not use the new error handling (for now)
133 - Remove scsi_qla_host_t and use 'struct' instead
134 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
135 pci_64bit_slot flags which weren't used for anything anyway
136 - Grab host->host_lock while calling qla1280_isr() from abort()
137 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
138 do not need to save/restore flags in the interrupt handler
139 - Enable interrupts early (before any mailbox access) in preparation
140 for cleaning up the mailbox handling
141 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
142 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
143 it with proper use of dprintk().
144 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
145 a debug level argument to determine if data is to be printed
146 - Add KERN_* info to printk()
147 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
148 - Significant cosmetic cleanups
149 - Change debug code to use dprintk() and remove #if mess
150 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
151 - More cosmetic cleanups, fix places treating return as function
152 - use cpu_relax() in qla1280_debounce_register()
153 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
154 - Make it compile under 2.5.5
155 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
156 - Do no typecast short * to long * in QL1280BoardTbl, this
157 broke miserably on big endian boxes
158 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
159 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
160 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
161 unsigned int to match the types from struct scsi_cmnd
162 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
163 - Remove bogus timer_t typedef from qla1280.h
164 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
165 for PCI_ values, call pci_set_master()
166 - Fix memleak of qla1280_buffer on module unload
167 - Only compile module parsing code #ifdef MODULE - should be
168 changed to use individual MODULE_PARM's later
169 - Remove dummy_buffer that was never modified nor printed
170 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
171 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
172 - Remove \r from print statements, this is Linux, not DOS
173 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
175 - Remove C++ compile hack in header file as Linux driver are not
176 supposed to be compiled as C++
177 - Kill MS_64BITS macro as it makes the code more readable
178 - Remove unnecessary flags.in_interrupts bit
179 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
180 - 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 before
183 - qla1280_status_entry(): Only zero out part of sense_buffer that
184 is not being copied into
185 - Remove more superflouous typecasts
186 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
187 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
188 - Don't walk the entire list in qla1280_putq_t() just to directly
189 grab the pointer to the last element afterwards
190 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
191 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
192 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
193 - Set dev->max_sectors to 1024
194 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
195 - Provide compat macros for pci_enable_device(), pci_find_subsys()
196 and scsi_set_pci_device()
197 - Call scsi_set_pci_device() for all devices
198 - Reduce size of kernel version dependent device probe code
199 - Move duplicate probe/init code to separate function
200 - Handle error if qla1280_mem_alloc() fails
201 - Kill OFFSET() macro and use Linux's PCI definitions instead
202 - Kill private structure defining PCI config space (struct config_reg)
203 - Only allocate I/O port region if not in MMIO mode
204 - Remove duplicate (unused) sanity check of sife of srb_t
205 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
206 - Change home-brew memset() implementations to use memset()
207 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
208 port directly is not legal under Linux.
209 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
210 - Remove pre 2.2 kernel support
211 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
212 - Fix MMIO access to use readl/writel instead of directly
213 dereferencing pointers
214 - Nuke MSDOS debugging code
215 - Change true/false data types to int from uint8_t
216 - Use int for counters instead of uint8_t etc.
217 - Clean up size & byte order conversion macro usage
218 Rev 3.23 Beta January 11, 2001 BN Qlogic
219 - Added check of device_id when handling non
220 QLA12160s during detect().
221 Rev 3.22 Beta January 5, 2001 BN Qlogic
222 - Changed queue_task() to schedule_task()
223 for kernels 2.4.0 and higher.
224 Note: 2.4.0-testxx kernels released prior to
225 the actual 2.4.0 kernel release on January 2001
226 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.22
229 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 Qlogic
233 - Changed criteria of 64/32 Bit mode of HBA
234 operation according to BITS_PER_LONG rather
235 than HBA's NVRAM setting of >4Gig memory bit;
236 so that the HBA auto-configures without the need
237 to setup each system individually.
238 Rev 3.20 Beta December 5, 2000 BN Qlogic
239 - Added priority handling to IA-64 onboard SCSI
240 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 Qlogic
245 - Declare driver_template for new kernel
246 (2.4.0 and greater) scsi initialization scheme.
247 - Update /proc/scsi entry for 2.3.18 kernels and
249 Rev 3.18 Beta October 10, 2000 BN Qlogic
250 - Changed scan order of adapters to map
251 the QLA12160 followed by the QLA1280.
252 Rev 3.17 Beta September 18, 2000 BN Qlogic
253 - Removed warnings for 32 bit 2.4.x compiles
254 - Corrected declared size for request and response
255 DMA addresses that are kept in each ha
256 Rev. 3.16 Beta August 25, 2000 BN Qlogic
257 - Corrected 64 bit addressing issue on IA-64
258 where the upper 32 bits were not properly
259 passed to the RISC engine.
260 Rev. 3.15 Beta August 22, 2000 BN Qlogic
261 - Modified qla1280_setup_chip to properly load
262 ISP firmware for greater that 4 Gig memory on IA-64
263 Rev. 3.14 Beta August 16, 2000 BN Qlogic
264 - Added setting of dma_mask to full 64 bit
265 if flags.enable_64bit_addressing is set in NVRAM
266 Rev. 3.13 Beta August 16, 2000 BN Qlogic
267 - Use new PCI DMA mapping APIs for 2.4.x kernel
268 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
269 - Added check of pci_enable_device to detect() for 2.3.x
270 - Use pci_resource_start() instead of
271 pdev->resource[0].start in detect() for 2.3.x
272 - Updated driver version
273 Rev. 3.11 July 14, 2000 BN Qlogic
274 - Updated SCSI Firmware to following versions:
277 - Updated driver version to 3.11
278 Rev. 3.10 June 23, 2000 BN Qlogic
279 - Added filtering of AMI SubSys Vendor ID devices
281 - DEBUG_QLA1280 undefined and new version BN Qlogic
282 Rev. 3.08b May 9, 2000 MD Dell
283 - Added logic to check against AMI subsystem vendor ID
284 Rev. 3.08 May 4, 2000 DG Qlogic
285 - Added logic to check for PCI subsystem ID.
286 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
287 - Updated SCSI Firmware to following versions:
290 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
291 - Internal revision; not released
292 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
293 - Edit correction for virt_to_bus and PROC.
294 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
295 - Merge changes from ia64 port.
296 Rev. 3.03 Mar 28, 2000 BN Qlogic
297 - Increase version to reflect new code drop with compile fix
298 of issue with inclusion of linux/spinlock for 2.3 kernels
299 Rev. 3.02 Mar 15, 2000 BN Qlogic
300 - Merge qla1280_proc_info from 2.10 code base
301 Rev. 3.01 Feb 10, 2000 BN Qlogic
302 - Corrected code to compile on a 2.2.x kernel.
303 Rev. 3.00 Jan 17, 2000 DG Qlogic
304 - Added 64-bit support.
305 Rev. 2.07 Nov 9, 1999 DG Qlogic
306 - Added new routine to set target parameters for ISP12160.
307 Rev. 2.06 Sept 10, 1999 DG Qlogic
308 - Added support for ISP12160 Ultra 3 chip.
309 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
310 - Modified code to remove errors generated when compiling with
311 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, Qlogic
320 Changes to support RedHat release 6.0 (kernel 2.2.5).
321 - Added SCSI exclusive access lock (io_request_lock) when accessing
323 - Added changes for the new LINUX interface template. Some new error
324 handling routines have been added to the template, but for now we
325 will use the old ones.
326 - Initial Beta Release.
327 *****************************************************************************/
330 #include <linux/module.h>
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>
350 #include <asm/byteorder.h>
351 #include <asm/processor.h>
352 #include <asm/types.h>
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>
362 * Compile time Options:
363 * 0 - Disable and 1 - Enable
365 #define DEBUG_QLA1280_INTR 0
366 #define DEBUG_PRINT_NVRAM 0
367 #define DEBUG_QLA1280 0
369 #define MEMORY_MAPPED_IO 1
373 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
374 #define QLA_64BIT_PTR 1
377 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */
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)
386 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
387 static void qla1280_remove_one(struct pci_dev *);
390 * QLogic Driver Support Function Prototypes.
392 static void qla1280_done(struct scsi_qla_host *);
393 static int qla1280_get_token(char *);
394 static int qla1280_setup(char *s) __init;
397 * QLogic ISP1280 Hardware Support Function Prototypes.
399 static int qla1280_load_firmware(struct scsi_qla_host *);
400 static int qla1280_init_rings(struct scsi_qla_host *);
401 static int qla1280_nvram_config(struct scsi_qla_host *);
402 static int qla1280_mailbox_command(struct scsi_qla_host *,
403 uint8_t, uint16_t *);
404 static int qla1280_bus_reset(struct scsi_qla_host *, int);
405 static int qla1280_device_reset(struct scsi_qla_host *, int, int);
406 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
407 static int qla1280_abort_isp(struct scsi_qla_host *);
409 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
411 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
413 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
414 static void qla1280_poll(struct scsi_qla_host *);
415 static void qla1280_reset_adapter(struct scsi_qla_host *);
416 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
417 static void qla1280_isp_cmd(struct scsi_qla_host *);
418 static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
419 static void qla1280_rst_aen(struct scsi_qla_host *);
420 static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
422 static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
424 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
425 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
426 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
427 static request_t *qla1280_req_pkt(struct scsi_qla_host *);
428 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
430 static void qla1280_get_target_parameters(struct scsi_qla_host *,
431 struct scsi_device *);
432 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
435 static struct qla_driver_setup driver_setup;
438 * convert scsi data direction to request_t control flags
440 static inline uint16_t
441 qla1280_data_direction(struct scsi_cmnd *cmnd)
443 switch(cmnd->sc_data_direction) {
444 case DMA_FROM_DEVICE:
448 case DMA_BIDIRECTIONAL:
449 return BIT_5 | BIT_6;
451 * We could BUG() on default here if one of the four cases aren't
452 * met, but then again if we receive something like that from the
453 * SCSI layer we have more serious problems. This shuts up GCC.
462 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
463 static void __qla1280_dump_buffer(char *, int);
468 * insmod needs to find the variable and make it point to something
471 static char *qla1280;
473 /* insmod qla1280 options=verbose" */
474 module_param(qla1280, charp, 0);
476 __setup("qla1280=", qla1280_setup);
481 * We use the scsi_pointer structure that's included with each scsi_command
482 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
483 * bigger than a scsi_pointer.
486 #define CMD_SP(Cmnd) &Cmnd->SCp
487 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
488 #define CMD_CDBP(Cmnd) Cmnd->cmnd
489 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
490 #define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
491 #define CMD_RESULT(Cmnd) Cmnd->result
492 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
494 #define CMD_HOST(Cmnd) Cmnd->device->host
495 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
496 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
497 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
500 /*****************************************/
501 /* ISP Boards supported by this driver */
502 /*****************************************/
505 char *name; /* Board ID String */
506 int numPorts; /* Number of SCSI ports */
507 int fw_index; /* index into qla1280_fw_tbl for firmware */
510 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
511 static struct pci_device_id qla1280_pci_tbl[] = {
512 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
513 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
514 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
515 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
516 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
517 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
518 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
519 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
520 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
521 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
522 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
523 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
526 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
528 static DEFINE_MUTEX(qla1280_firmware_mutex);
532 const struct firmware *fw;
535 #define QL_NUM_FW_IMAGES 3
537 static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
538 {"qlogic/1040.bin", NULL}, /* image 0 */
539 {"qlogic/1280.bin", NULL}, /* image 1 */
540 {"qlogic/12160.bin", NULL}, /* image 2 */
543 /* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
544 static struct qla_boards ql1280_board_tbl[] = {
545 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
546 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
547 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
548 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
549 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
550 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
551 {.name = " ", .numPorts = 0, .fw_index = -1},
554 static int qla1280_verbose = 1;
557 static int ql_debug_level = 1;
558 #define dprintk(level, format, a...) \
559 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
560 #define qla1280_dump_buffer(level, buf, size) \
561 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
562 #define qla1280_print_scsi_cmd(level, cmd) \
563 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
565 #define ql_debug_level 0
566 #define dprintk(level, format, a...) do{}while(0)
567 #define qla1280_dump_buffer(a, b, c) do{}while(0)
568 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
571 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
572 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
573 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
574 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
577 static int qla1280_read_nvram(struct scsi_qla_host *ha)
584 ENTER("qla1280_read_nvram");
586 if (driver_setup.no_nvram)
589 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
591 wptr = (uint16_t *)&ha->nvram;
594 for (cnt = 0; cnt < 3; cnt++) {
595 *wptr = qla1280_get_nvram_word(ha, cnt);
596 chksum += *wptr & 0xff;
597 chksum += (*wptr >> 8) & 0xff;
601 if (nv->id0 != 'I' || nv->id1 != 'S' ||
602 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
603 dprintk(2, "Invalid nvram ID or version!\n");
606 for (; cnt < sizeof(struct nvram); cnt++) {
607 *wptr = qla1280_get_nvram_word(ha, cnt);
608 chksum += *wptr & 0xff;
609 chksum += (*wptr >> 8) & 0xff;
614 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
615 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
620 if (!driver_setup.no_nvram)
621 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
622 "validate NVRAM checksum, using default "
623 "settings\n", ha->host_no);
628 /* The firmware interface is, um, interesting, in that the
629 * actual firmware image on the chip is little endian, thus,
630 * the process of taking that image to the CPU would end up
631 * little endian. However, the firmware interface requires it
632 * to be read a word (two bytes) at a time.
634 * The net result of this would be that the word (and
635 * doubleword) quantities in the firmware would be correct, but
636 * the bytes would be pairwise reversed. Since most of the
637 * firmware quantities are, in fact, bytes, we do an extra
638 * le16_to_cpu() in the firmware read routine.
640 * The upshot of all this is that the bytes in the firmware
641 * are in the correct places, but the 16 and 32 bit quantities
642 * are still in little endian format. We fix that up below by
643 * doing extra reverses on them */
644 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
645 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
646 for(i = 0; i < MAX_BUSES; i++) {
647 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
648 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
650 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
651 LEAVE("qla1280_read_nvram");
656 /**************************************************************************
658 * Return a string describing the driver.
659 **************************************************************************/
661 qla1280_info(struct Scsi_Host *host)
663 static char qla1280_scsi_name_buffer[125];
665 struct scsi_qla_host *ha;
666 struct qla_boards *bdp;
668 bp = &qla1280_scsi_name_buffer[0];
669 ha = (struct scsi_qla_host *)host->hostdata;
670 bdp = &ql1280_board_tbl[ha->devnum];
671 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
674 "QLogic %s PCI to SCSI Host Adapter\n"
675 " Firmware version: %2d.%02d.%02d, Driver version %s",
676 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
681 /**************************************************************************
682 * qla1280_queuecommand
683 * Queue a command to the controller.
686 * The mid-level driver tries to ensures that queuecommand never gets invoked
687 * concurrently with itself or the interrupt handler (although the
688 * interrupt handler may call this routine as part of request-completion
689 * handling). Unfortunately, it sometimes calls the scheduler in interrupt
690 * context which is a big NO! NO!.
691 **************************************************************************/
693 qla1280_queuecommand_lck(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
695 struct Scsi_Host *host = cmd->device->host;
696 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
697 struct srb *sp = (struct srb *)CMD_SP(cmd);
704 CMD_HANDLE(cmd) = (unsigned char *)NULL;
706 qla1280_print_scsi_cmd(5, cmd);
710 * Using 64 bit commands if the PCI bridge doesn't support it is a
711 * bit wasteful, however this should really only happen if one's
712 * PCI controller is completely broken, like the BCM1250. For
713 * sane hardware this is not an issue.
715 status = qla1280_64bit_start_scsi(ha, sp);
717 status = qla1280_32bit_start_scsi(ha, sp);
722 static DEF_SCSI_QCMD(qla1280_queuecommand)
732 static void qla1280_mailbox_timeout(struct timer_list *t)
734 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
735 struct device_reg __iomem *reg;
738 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
739 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
740 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
741 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
742 complete(ha->mailbox_wait);
746 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
747 struct completion *wait)
750 struct scsi_cmnd *cmd = sp->cmd;
752 spin_unlock_irq(ha->host->host_lock);
753 wait_for_completion_timeout(wait, 4*HZ);
754 spin_lock_irq(ha->host->host_lock);
756 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
758 (*cmd->scsi_done)(cmd);
764 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
766 DECLARE_COMPLETION_ONSTACK(wait);
769 return _qla1280_wait_for_single_command(ha, sp, &wait);
773 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
778 struct scsi_cmnd *cmd;
783 * Wait for all commands with the designated bus/target
784 * to be completed by the firmware
786 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
787 sp = ha->outstanding_cmds[cnt];
791 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
793 if (target >= 0 && SCSI_TCN_32(cmd) != target)
796 status = qla1280_wait_for_single_command(ha, sp);
797 if (status == FAILED)
804 /**************************************************************************
805 * qla1280_error_action
806 * The function will attempt to perform a specified error action and
807 * wait for the results (or time out).
810 * cmd = Linux SCSI command packet of the command that cause the
812 * action = error action to take (see action_t)
817 **************************************************************************/
819 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
821 struct scsi_qla_host *ha;
822 int bus, target, lun;
827 int wait_for_target = -1;
828 DECLARE_COMPLETION_ONSTACK(wait);
830 ENTER("qla1280_error_action");
832 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
833 sp = (struct srb *)CMD_SP(cmd);
834 bus = SCSI_BUS_32(cmd);
835 target = SCSI_TCN_32(cmd);
836 lun = SCSI_LUN_32(cmd);
838 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
839 RD_REG_WORD(&ha->iobase->istatus));
841 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
842 RD_REG_WORD(&ha->iobase->host_cmd),
843 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
846 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
847 "Handle=0x%p, action=0x%x\n",
848 ha->host_no, cmd, CMD_HANDLE(cmd), action);
851 * Check to see if we have the command in the outstanding_cmds[]
852 * array. If not then it must have completed before this error
853 * action was initiated. If the error_action isn't ABORT_COMMAND
854 * then the driver must proceed with the requested action.
857 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
858 if (sp == ha->outstanding_cmds[i]) {
860 sp->wait = &wait; /* we'll wait for it to complete */
865 if (found < 0) { /* driver doesn't have command */
867 if (qla1280_verbose) {
869 "scsi(%ld:%d:%d:%d): specified command has "
870 "already completed.\n", ha->host_no, bus,
878 dprintk(1, "qla1280: RISC aborting command\n");
880 * The abort might fail due to race when the host_lock
881 * is released to issue the abort. As such, we
882 * don't bother to check the return status.
885 qla1280_abort_command(ha, sp, found);
891 "scsi(%ld:%d:%d:%d): Queueing device reset "
892 "command.\n", ha->host_no, bus, target, lun);
893 if (qla1280_device_reset(ha, bus, target) == 0) {
894 /* issued device reset, set wait conditions */
896 wait_for_target = target;
902 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
903 "reset.\n", ha->host_no, bus);
904 if (qla1280_bus_reset(ha, bus) == 0) {
905 /* issued bus reset, set wait conditions */
912 if (qla1280_verbose) {
914 "scsi(%ld): Issued ADAPTER RESET\n",
916 printk(KERN_INFO "scsi(%ld): I/O processing will "
917 "continue automatically\n", ha->host_no);
919 ha->flags.reset_active = 1;
921 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
925 ha->flags.reset_active = 0;
929 * At this point, the host_lock has been released and retaken
930 * by the issuance of the mailbox command.
931 * Wait for the command passed in by the mid-layer if it
932 * was found by the driver. It might have been returned
933 * between eh recovery steps, hence the check of the "found"
938 result = _qla1280_wait_for_single_command(ha, sp, &wait);
940 if (action == ABORT_COMMAND && result != SUCCESS) {
942 "scsi(%li:%i:%i:%i): "
943 "Unable to abort command!\n",
944 ha->host_no, bus, target, lun);
948 * If the command passed in by the mid-layer has been
949 * returned by the board, then wait for any additional
950 * commands which are supposed to complete based upon
953 * All commands are unconditionally returned during a
954 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
957 if (result == SUCCESS && wait_for_bus >= 0) {
958 result = qla1280_wait_for_pending_commands(ha,
959 wait_for_bus, wait_for_target);
962 dprintk(1, "RESET returning %d\n", result);
964 LEAVE("qla1280_error_action");
968 /**************************************************************************
970 * Abort the specified SCSI command(s).
971 **************************************************************************/
973 qla1280_eh_abort(struct scsi_cmnd * cmd)
977 spin_lock_irq(cmd->device->host->host_lock);
978 rc = qla1280_error_action(cmd, ABORT_COMMAND);
979 spin_unlock_irq(cmd->device->host->host_lock);
984 /**************************************************************************
985 * qla1280_device_reset
986 * Reset the specified SCSI device
987 **************************************************************************/
989 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
993 spin_lock_irq(cmd->device->host->host_lock);
994 rc = qla1280_error_action(cmd, DEVICE_RESET);
995 spin_unlock_irq(cmd->device->host->host_lock);
1000 /**************************************************************************
1002 * Reset the specified bus.
1003 **************************************************************************/
1005 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1009 spin_lock_irq(cmd->device->host->host_lock);
1010 rc = qla1280_error_action(cmd, BUS_RESET);
1011 spin_unlock_irq(cmd->device->host->host_lock);
1016 /**************************************************************************
1017 * qla1280_adapter_reset
1018 * Reset the specified adapter (both channels)
1019 **************************************************************************/
1021 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1025 spin_lock_irq(cmd->device->host->host_lock);
1026 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1027 spin_unlock_irq(cmd->device->host->host_lock);
1033 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1034 sector_t capacity, int geom[])
1036 int heads, sectors, cylinders;
1040 cylinders = (unsigned long)capacity / (heads * sectors);
1041 if (cylinders > 1024) {
1044 cylinders = (unsigned long)capacity / (heads * sectors);
1045 /* if (cylinders > 1023)
1046 cylinders = 1023; */
1051 geom[2] = cylinders;
1057 /* disable risc and host interrupts */
1059 qla1280_disable_intrs(struct scsi_qla_host *ha)
1061 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1062 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1065 /* enable risc and host interrupts */
1067 qla1280_enable_intrs(struct scsi_qla_host *ha)
1069 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1070 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1073 /**************************************************************************
1074 * qla1280_intr_handler
1075 * Handles the H/W interrupt
1076 **************************************************************************/
1078 qla1280_intr_handler(int irq, void *dev_id)
1080 struct scsi_qla_host *ha;
1081 struct device_reg __iomem *reg;
1085 ENTER_INTR ("qla1280_intr_handler");
1086 ha = (struct scsi_qla_host *)dev_id;
1088 spin_lock(ha->host->host_lock);
1093 qla1280_disable_intrs(ha);
1095 data = qla1280_debounce_register(®->istatus);
1096 /* Check for pending interrupts. */
1097 if (data & RISC_INT) {
1098 qla1280_isr(ha, &ha->done_q);
1101 if (!list_empty(&ha->done_q))
1104 spin_unlock(ha->host->host_lock);
1106 qla1280_enable_intrs(ha);
1108 LEAVE_INTR("qla1280_intr_handler");
1109 return IRQ_RETVAL(handled);
1114 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1117 uint16_t mb[MAILBOX_REGISTER_COUNT];
1123 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1125 /* Set Target Parameters. */
1126 mb[0] = MBC_SET_TARGET_PARAMETERS;
1127 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1128 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1129 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1130 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1131 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1132 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1133 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1134 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1135 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1137 if (IS_ISP1x160(ha)) {
1138 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1139 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1140 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1141 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1144 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1146 mb[3] |= nv->bus[bus].target[target].sync_period;
1148 status = qla1280_mailbox_command(ha, mr, mb);
1150 /* Set Device Queue Parameters. */
1151 for (lun = 0; lun < MAX_LUNS; lun++) {
1152 mb[0] = MBC_SET_DEVICE_QUEUE;
1153 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1155 mb[2] = nv->bus[bus].max_queue_depth;
1156 mb[3] = nv->bus[bus].target[target].execution_throttle;
1157 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1161 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1162 "qla1280_set_target_parameters() failed\n",
1163 ha->host_no, bus, target);
1168 /**************************************************************************
1169 * qla1280_slave_configure
1172 * Determines the queue depth for a given device. There are two ways
1173 * a queue depth can be obtained for a tagged queueing device. One
1174 * way is the default queue depth which is determined by whether
1175 * If it is defined, then it is used
1176 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1177 * default queue depth (dependent on the number of hardware SCBs).
1178 **************************************************************************/
1180 qla1280_slave_configure(struct scsi_device *device)
1182 struct scsi_qla_host *ha;
1183 int default_depth = 3;
1184 int bus = device->channel;
1185 int target = device->id;
1188 unsigned long flags;
1190 ha = (struct scsi_qla_host *)device->host->hostdata;
1193 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1196 if (device->tagged_supported &&
1197 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1198 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1200 scsi_change_queue_depth(device, default_depth);
1203 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1204 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1205 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1207 if (driver_setup.no_sync ||
1208 (driver_setup.sync_mask &&
1209 (~driver_setup.sync_mask & (1 << target))))
1210 nv->bus[bus].target[target].parameter.enable_sync = 0;
1211 if (driver_setup.no_wide ||
1212 (driver_setup.wide_mask &&
1213 (~driver_setup.wide_mask & (1 << target))))
1214 nv->bus[bus].target[target].parameter.enable_wide = 0;
1215 if (IS_ISP1x160(ha)) {
1216 if (driver_setup.no_ppr ||
1217 (driver_setup.ppr_mask &&
1218 (~driver_setup.ppr_mask & (1 << target))))
1219 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1222 spin_lock_irqsave(ha->host->host_lock, flags);
1223 if (nv->bus[bus].target[target].parameter.enable_sync)
1224 status = qla1280_set_target_parameters(ha, bus, target);
1225 qla1280_get_target_parameters(ha, device);
1226 spin_unlock_irqrestore(ha->host->host_lock, flags);
1233 * Process completed commands.
1236 * ha = adapter block pointer.
1239 qla1280_done(struct scsi_qla_host *ha)
1242 struct list_head *done_q;
1244 struct scsi_cmnd *cmd;
1246 ENTER("qla1280_done");
1248 done_q = &ha->done_q;
1250 while (!list_empty(done_q)) {
1251 sp = list_entry(done_q->next, struct srb, list);
1253 list_del(&sp->list);
1256 bus = SCSI_BUS_32(cmd);
1257 target = SCSI_TCN_32(cmd);
1259 switch ((CMD_RESULT(cmd) >> 16)) {
1261 /* Issue marker command. */
1262 if (!ha->flags.abort_isp_active)
1263 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1266 sp->flags &= ~SRB_ABORT_PENDING;
1267 sp->flags |= SRB_ABORTED;
1273 /* Release memory used for this I/O */
1274 scsi_dma_unmap(cmd);
1276 /* Call the mid-level driver interrupt handler */
1279 if (sp->wait == NULL)
1280 (*(cmd)->scsi_done)(cmd);
1284 LEAVE("qla1280_done");
1288 * Translates a ISP error to a Linux SCSI error
1291 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1293 int host_status = DID_ERROR;
1294 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1295 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1296 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1297 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1298 #if DEBUG_QLA1280_INTR
1299 static char *reason[] = {
1311 #endif /* DEBUG_QLA1280_INTR */
1313 ENTER("qla1280_return_status");
1315 #if DEBUG_QLA1280_INTR
1317 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1322 switch (comp_status) {
1324 host_status = DID_OK;
1328 if (!(state_flags & SF_GOT_BUS))
1329 host_status = DID_NO_CONNECT;
1330 else if (!(state_flags & SF_GOT_TARGET))
1331 host_status = DID_BAD_TARGET;
1332 else if (!(state_flags & SF_SENT_CDB))
1333 host_status = DID_ERROR;
1334 else if (!(state_flags & SF_TRANSFERRED_DATA))
1335 host_status = DID_ERROR;
1336 else if (!(state_flags & SF_GOT_STATUS))
1337 host_status = DID_ERROR;
1338 else if (!(state_flags & SF_GOT_SENSE))
1339 host_status = DID_ERROR;
1343 host_status = DID_RESET;
1347 host_status = DID_ABORT;
1351 host_status = DID_TIME_OUT;
1354 case CS_DATA_OVERRUN:
1355 dprintk(2, "Data overrun 0x%x\n", residual_length);
1356 dprintk(2, "qla1280_return_status: response packet data\n");
1357 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1358 host_status = DID_ERROR;
1361 case CS_DATA_UNDERRUN:
1362 if ((scsi_bufflen(cp) - residual_length) <
1365 "scsi: Underflow detected - retrying "
1367 host_status = DID_ERROR;
1369 scsi_set_resid(cp, residual_length);
1370 host_status = DID_OK;
1375 host_status = DID_ERROR;
1379 #if DEBUG_QLA1280_INTR
1380 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1381 reason[host_status], scsi_status);
1384 LEAVE("qla1280_return_status");
1386 return (scsi_status & 0xff) | (host_status << 16);
1389 /****************************************************************************/
1390 /* QLogic ISP1280 Hardware Support Functions. */
1391 /****************************************************************************/
1394 * qla1280_initialize_adapter
1398 * ha = adapter block pointer.
1404 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1406 struct device_reg __iomem *reg;
1409 unsigned long flags;
1411 ENTER("qla1280_initialize_adapter");
1413 /* Clear adapter flags. */
1414 ha->flags.online = 0;
1415 ha->flags.disable_host_adapter = 0;
1416 ha->flags.reset_active = 0;
1417 ha->flags.abort_isp_active = 0;
1419 /* TODO: implement support for the 1040 nvram format */
1421 driver_setup.no_nvram = 1;
1423 dprintk(1, "Configure PCI space for adapter...\n");
1427 /* Insure mailbox registers are free. */
1428 WRT_REG_WORD(®->semaphore, 0);
1429 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1430 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1431 RD_REG_WORD(®->host_cmd);
1433 if (qla1280_read_nvram(ha)) {
1434 dprintk(2, "qla1280_initialize_adapter: failed to read "
1439 * It's necessary to grab the spin here as qla1280_mailbox_command
1440 * needs to be able to drop the lock unconditionally to wait
1443 spin_lock_irqsave(ha->host->host_lock, flags);
1445 status = qla1280_load_firmware(ha);
1447 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1452 /* Setup adapter based on NVRAM parameters. */
1453 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1454 qla1280_nvram_config(ha);
1456 if (ha->flags.disable_host_adapter) {
1461 status = qla1280_init_rings(ha);
1465 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1466 for (bus = 0; bus < ha->ports; bus++) {
1467 if (!ha->bus_settings[bus].disable_scsi_reset &&
1468 qla1280_bus_reset(ha, bus) &&
1469 qla1280_bus_reset(ha, bus))
1470 ha->bus_settings[bus].scsi_bus_dead = 1;
1473 ha->flags.online = 1;
1475 spin_unlock_irqrestore(ha->host->host_lock, flags);
1478 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1480 LEAVE("qla1280_initialize_adapter");
1485 * qla1280_request_firmware
1486 * Acquire firmware for chip. Retain in memory
1487 * for error recovery.
1490 * ha = adapter block pointer.
1493 * Pointer to firmware image or an error code
1494 * cast to pointer via ERR_PTR().
1496 static const struct firmware *
1497 qla1280_request_firmware(struct scsi_qla_host *ha)
1499 const struct firmware *fw;
1504 spin_unlock_irq(ha->host->host_lock);
1505 mutex_lock(&qla1280_firmware_mutex);
1507 index = ql1280_board_tbl[ha->devnum].fw_index;
1508 fw = qla1280_fw_tbl[index].fw;
1512 fwname = qla1280_fw_tbl[index].fwname;
1513 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1516 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1521 if ((fw->size % 2) || (fw->size < 6)) {
1522 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1524 release_firmware(fw);
1525 fw = ERR_PTR(-EINVAL);
1529 qla1280_fw_tbl[index].fw = fw;
1532 ha->fwver1 = fw->data[0];
1533 ha->fwver2 = fw->data[1];
1534 ha->fwver3 = fw->data[2];
1536 mutex_unlock(&qla1280_firmware_mutex);
1537 spin_lock_irq(ha->host->host_lock);
1543 * Test chip for proper operation.
1546 * ha = adapter block pointer.
1552 qla1280_chip_diag(struct scsi_qla_host *ha)
1554 uint16_t mb[MAILBOX_REGISTER_COUNT];
1555 struct device_reg __iomem *reg = ha->iobase;
1559 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1561 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1563 /* Soft reset chip and wait for it to finish. */
1564 WRT_REG_WORD(®->ictrl, ISP_RESET);
1567 * We can't do a traditional PCI write flush here by reading
1568 * back the register. The card will not respond once the reset
1569 * is in action and we end up with a machine check exception
1570 * instead. Nothing to do but wait and hope for the best.
1571 * A portable pci_write_flush(pdev) call would be very useful here.
1574 data = qla1280_debounce_register(®->ictrl);
1576 * Yet another QLogic gem ;-(
1578 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1580 data = RD_REG_WORD(®->ictrl);
1586 /* Reset register cleared by chip reset. */
1587 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1589 WRT_REG_WORD(®->cfg_1, 0);
1591 /* Reset RISC and disable BIOS which
1592 allows RISC to execute out of RAM. */
1593 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1594 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1596 RD_REG_WORD(®->id_l); /* Flush PCI write */
1597 data = qla1280_debounce_register(®->mailbox0);
1600 * I *LOVE* this code!
1602 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1604 data = RD_REG_WORD(®->mailbox0);
1610 /* Check product ID of chip */
1611 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1613 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1614 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1615 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1616 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1617 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1618 printk(KERN_INFO "qla1280: Wrong product ID = "
1619 "0x%x,0x%x,0x%x,0x%x\n",
1620 RD_REG_WORD(®->mailbox1),
1621 RD_REG_WORD(®->mailbox2),
1622 RD_REG_WORD(®->mailbox3),
1623 RD_REG_WORD(®->mailbox4));
1628 * Enable ints early!!!
1630 qla1280_enable_intrs(ha);
1632 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1633 /* Wrap Incoming Mailboxes Test. */
1634 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1643 status = qla1280_mailbox_command(ha, 0xff, mb);
1647 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1648 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1650 printk(KERN_INFO "qla1280: Failed mbox check\n");
1654 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1657 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1662 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1664 /* enter with host_lock acquired */
1666 const struct firmware *fw;
1667 const __le16 *fw_data;
1668 uint16_t risc_address, risc_code_size;
1669 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1672 fw = qla1280_request_firmware(ha);
1676 fw_data = (const __le16 *)&fw->data[0];
1677 ha->fwstart = __le16_to_cpu(fw_data[2]);
1679 /* Load RISC code. */
1680 risc_address = ha->fwstart;
1681 fw_data = (const __le16 *)&fw->data[6];
1682 risc_code_size = (fw->size - 6) / 2;
1684 for (i = 0; i < risc_code_size; i++) {
1685 mb[0] = MBC_WRITE_RAM_WORD;
1686 mb[1] = risc_address + i;
1687 mb[2] = __le16_to_cpu(fw_data[i]);
1689 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1691 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1700 #ifdef QLA_64BIT_PTR
1701 #define LOAD_CMD MBC_LOAD_RAM_A64_ROM
1702 #define DUMP_CMD MBC_DUMP_RAM_A64_ROM
1703 #define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1705 #define LOAD_CMD MBC_LOAD_RAM
1706 #define DUMP_CMD MBC_DUMP_RAM
1707 #define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1710 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1712 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1714 /* enter with host_lock acquired */
1715 const struct firmware *fw;
1716 const __le16 *fw_data;
1717 uint16_t risc_address, risc_code_size;
1718 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1719 int err = 0, num, i;
1724 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1729 fw = qla1280_request_firmware(ha);
1733 fw_data = (const __le16 *)&fw->data[0];
1734 ha->fwstart = __le16_to_cpu(fw_data[2]);
1736 /* Load RISC code. */
1737 risc_address = ha->fwstart;
1738 fw_data = (const __le16 *)&fw->data[6];
1739 risc_code_size = (fw->size - 6) / 2;
1741 dprintk(1, "%s: DMA RISC code (%i) words\n",
1742 __func__, risc_code_size);
1745 while (risc_code_size > 0) {
1746 int warn __attribute__((unused)) = 0;
1750 if (cnt > risc_code_size)
1751 cnt = risc_code_size;
1753 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1755 fw_data, cnt, num, risc_address);
1756 for(i = 0; i < cnt; i++)
1757 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1760 mb[1] = risc_address;
1762 mb[3] = ha->request_dma & 0xffff;
1763 mb[2] = (ha->request_dma >> 16) & 0xffff;
1764 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1765 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1766 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1768 (void *)(long)ha->request_dma,
1769 mb[6], mb[7], mb[2], mb[3]);
1770 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1772 printk(KERN_ERR "scsi(%li): Failed to load partial "
1773 "segment of f\n", ha->host_no);
1779 mb[1] = risc_address;
1781 mb[3] = p_tbuf & 0xffff;
1782 mb[2] = (p_tbuf >> 16) & 0xffff;
1783 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1784 mb[6] = upper_32_bits(p_tbuf) >> 16;
1786 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1789 "Failed to dump partial segment of f/w\n");
1792 sp = (uint8_t *)ha->request_ring;
1793 for (i = 0; i < (cnt << 1); i++) {
1794 if (tbuf[i] != sp[i] && warn++ < 10) {
1795 printk(KERN_ERR "%s: FW compare error @ "
1796 "byte(0x%x) loop#=%x\n",
1798 printk(KERN_ERR "%s: FWbyte=%x "
1800 __func__, sp[i], tbuf[i]);
1805 risc_address += cnt;
1806 risc_code_size = risc_code_size - cnt;
1807 fw_data = fw_data + cnt;
1813 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1819 qla1280_start_firmware(struct scsi_qla_host *ha)
1821 uint16_t mb[MAILBOX_REGISTER_COUNT];
1824 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1827 /* Verify checksum of loaded RISC code. */
1828 mb[0] = MBC_VERIFY_CHECKSUM;
1829 /* mb[1] = ql12_risc_code_addr01; */
1830 mb[1] = ha->fwstart;
1831 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1833 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1837 /* Start firmware execution. */
1838 dprintk(1, "%s: start firmware running.\n", __func__);
1839 mb[0] = MBC_EXECUTE_FIRMWARE;
1840 mb[1] = ha->fwstart;
1841 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1843 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1851 qla1280_load_firmware(struct scsi_qla_host *ha)
1853 /* enter with host_lock taken */
1856 err = qla1280_chip_diag(ha);
1860 err = qla1280_load_firmware_pio(ha);
1862 err = qla1280_load_firmware_dma(ha);
1865 err = qla1280_start_firmware(ha);
1874 * ha = adapter block pointer.
1875 * ha->request_ring = request ring virtual address
1876 * ha->response_ring = response ring virtual address
1877 * ha->request_dma = request ring physical address
1878 * ha->response_dma = response ring physical address
1884 qla1280_init_rings(struct scsi_qla_host *ha)
1886 uint16_t mb[MAILBOX_REGISTER_COUNT];
1889 ENTER("qla1280_init_rings");
1891 /* Clear outstanding commands array. */
1892 memset(ha->outstanding_cmds, 0,
1893 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1895 /* Initialize request queue. */
1896 ha->request_ring_ptr = ha->request_ring;
1897 ha->req_ring_index = 0;
1898 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1899 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1900 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1901 mb[1] = REQUEST_ENTRY_CNT;
1902 mb[3] = ha->request_dma & 0xffff;
1903 mb[2] = (ha->request_dma >> 16) & 0xffff;
1905 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1906 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1907 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1908 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1910 /* Initialize response queue. */
1911 ha->response_ring_ptr = ha->response_ring;
1912 ha->rsp_ring_index = 0;
1913 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1914 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1915 mb[1] = RESPONSE_ENTRY_CNT;
1916 mb[3] = ha->response_dma & 0xffff;
1917 mb[2] = (ha->response_dma >> 16) & 0xffff;
1919 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1920 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1921 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1922 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1927 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1929 LEAVE("qla1280_init_rings");
1934 qla1280_print_settings(struct nvram *nv)
1936 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1937 nv->bus[0].config_1.initiator_id);
1938 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1939 nv->bus[1].config_1.initiator_id);
1941 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1942 nv->bus[0].bus_reset_delay);
1943 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1944 nv->bus[1].bus_reset_delay);
1946 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1947 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1948 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1949 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1951 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1952 nv->bus[0].config_2.async_data_setup_time);
1953 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1954 nv->bus[1].config_2.async_data_setup_time);
1956 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1957 nv->bus[0].config_2.req_ack_active_negation);
1958 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1959 nv->bus[1].config_2.req_ack_active_negation);
1961 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1962 nv->bus[0].config_2.data_line_active_negation);
1963 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1964 nv->bus[1].config_2.data_line_active_negation);
1966 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1967 nv->cntr_flags_1.disable_loading_risc_code);
1969 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1970 nv->cntr_flags_1.enable_64bit_addressing);
1972 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1973 nv->bus[0].selection_timeout);
1974 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1975 nv->bus[1].selection_timeout);
1977 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1978 nv->bus[0].max_queue_depth);
1979 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1980 nv->bus[1].max_queue_depth);
1984 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1986 struct nvram *nv = &ha->nvram;
1988 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
1989 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
1990 nv->bus[bus].target[target].parameter.tag_queuing = 1;
1991 nv->bus[bus].target[target].parameter.enable_sync = 1;
1992 #if 1 /* Some SCSI Processors do not seem to like this */
1993 nv->bus[bus].target[target].parameter.enable_wide = 1;
1995 nv->bus[bus].target[target].execution_throttle =
1996 nv->bus[bus].max_queue_depth - 1;
1997 nv->bus[bus].target[target].parameter.parity_checking = 1;
1998 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
2000 if (IS_ISP1x160(ha)) {
2001 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2002 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2003 nv->bus[bus].target[target].sync_period = 9;
2004 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2005 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2006 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2008 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2009 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2010 nv->bus[bus].target[target].sync_period = 10;
2015 qla1280_set_defaults(struct scsi_qla_host *ha)
2017 struct nvram *nv = &ha->nvram;
2020 dprintk(1, "Using defaults for NVRAM: \n");
2021 memset(nv, 0, sizeof(struct nvram));
2023 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2024 nv->firmware_feature.f.enable_fast_posting = 1;
2025 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2026 nv->termination.scsi_bus_0_control = 3;
2027 nv->termination.scsi_bus_1_control = 3;
2028 nv->termination.auto_term_support = 1;
2031 * Set default FIFO magic - What appropriate values would be here
2032 * is unknown. This is what I have found testing with 12160s.
2034 * Now, I would love the magic decoder ring for this one, the
2035 * header file provided by QLogic seems to be bogus or incomplete
2038 nv->isp_config.burst_enable = 1;
2040 nv->isp_config.fifo_threshold |= 3;
2042 nv->isp_config.fifo_threshold |= 4;
2044 if (IS_ISP1x160(ha))
2045 nv->isp_parameter = 0x01; /* fast memory enable */
2047 for (bus = 0; bus < MAX_BUSES; bus++) {
2048 nv->bus[bus].config_1.initiator_id = 7;
2049 nv->bus[bus].config_2.req_ack_active_negation = 1;
2050 nv->bus[bus].config_2.data_line_active_negation = 1;
2051 nv->bus[bus].selection_timeout = 250;
2052 nv->bus[bus].max_queue_depth = 32;
2054 if (IS_ISP1040(ha)) {
2055 nv->bus[bus].bus_reset_delay = 3;
2056 nv->bus[bus].config_2.async_data_setup_time = 6;
2057 nv->bus[bus].retry_delay = 1;
2059 nv->bus[bus].bus_reset_delay = 5;
2060 nv->bus[bus].config_2.async_data_setup_time = 8;
2063 for (target = 0; target < MAX_TARGETS; target++)
2064 qla1280_set_target_defaults(ha, bus, target);
2069 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2071 struct nvram *nv = &ha->nvram;
2072 uint16_t mb[MAILBOX_REGISTER_COUNT];
2076 /* Set Target Parameters. */
2077 mb[0] = MBC_SET_TARGET_PARAMETERS;
2078 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2081 * Do not enable sync and ppr for the initial INQUIRY run. We
2082 * enable this later if we determine the target actually
2085 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2086 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2088 if (IS_ISP1x160(ha))
2089 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2091 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2092 mb[3] |= nv->bus[bus].target[target].sync_period;
2093 status = qla1280_mailbox_command(ha, 0x0f, mb);
2095 /* Save Tag queuing enable flag. */
2096 flag = (BIT_0 << target);
2097 if (nv->bus[bus].target[target].parameter.tag_queuing)
2098 ha->bus_settings[bus].qtag_enables |= flag;
2100 /* Save Device enable flag. */
2101 if (IS_ISP1x160(ha)) {
2102 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2103 ha->bus_settings[bus].device_enables |= flag;
2104 ha->bus_settings[bus].lun_disables |= 0;
2106 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2107 ha->bus_settings[bus].device_enables |= flag;
2108 /* Save LUN disable flag. */
2109 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2110 ha->bus_settings[bus].lun_disables |= flag;
2113 /* Set Device Queue Parameters. */
2114 for (lun = 0; lun < MAX_LUNS; lun++) {
2115 mb[0] = MBC_SET_DEVICE_QUEUE;
2116 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2118 mb[2] = nv->bus[bus].max_queue_depth;
2119 mb[3] = nv->bus[bus].target[target].execution_throttle;
2120 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2127 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2129 struct nvram *nv = &ha->nvram;
2130 uint16_t mb[MAILBOX_REGISTER_COUNT];
2133 /* SCSI Reset Disable. */
2134 ha->bus_settings[bus].disable_scsi_reset =
2135 nv->bus[bus].config_1.scsi_reset_disable;
2138 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2139 mb[0] = MBC_SET_INITIATOR_ID;
2140 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2141 ha->bus_settings[bus].id;
2142 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2145 ha->bus_settings[bus].bus_reset_delay =
2146 nv->bus[bus].bus_reset_delay;
2148 /* Command queue depth per device. */
2149 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2151 /* Set target parameters. */
2152 for (target = 0; target < MAX_TARGETS; target++)
2153 status |= qla1280_config_target(ha, bus, target);
2159 qla1280_nvram_config(struct scsi_qla_host *ha)
2161 struct device_reg __iomem *reg = ha->iobase;
2162 struct nvram *nv = &ha->nvram;
2163 int bus, target, status = 0;
2164 uint16_t mb[MAILBOX_REGISTER_COUNT];
2166 ENTER("qla1280_nvram_config");
2168 if (ha->nvram_valid) {
2169 /* Always force AUTO sense for LINUX SCSI */
2170 for (bus = 0; bus < MAX_BUSES; bus++)
2171 for (target = 0; target < MAX_TARGETS; target++) {
2172 nv->bus[bus].target[target].parameter.
2173 auto_request_sense = 1;
2176 qla1280_set_defaults(ha);
2179 qla1280_print_settings(nv);
2181 /* Disable RISC load of firmware. */
2182 ha->flags.disable_risc_code_load =
2183 nv->cntr_flags_1.disable_loading_risc_code;
2185 if (IS_ISP1040(ha)) {
2186 uint16_t hwrev, cfg1, cdma_conf;
2188 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2190 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2191 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2193 /* Busted fifo, says mjacob. */
2194 if (hwrev != ISP_CFG0_1040A)
2195 cfg1 |= nv->isp_config.fifo_threshold << 4;
2197 cfg1 |= nv->isp_config.burst_enable << 2;
2198 WRT_REG_WORD(®->cfg_1, cfg1);
2200 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2201 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2203 uint16_t cfg1, term;
2205 /* Set ISP hardware DMA burst */
2206 cfg1 = nv->isp_config.fifo_threshold << 4;
2207 cfg1 |= nv->isp_config.burst_enable << 2;
2208 /* Enable DMA arbitration on dual channel controllers */
2211 WRT_REG_WORD(®->cfg_1, cfg1);
2213 /* Set SCSI termination. */
2214 WRT_REG_WORD(®->gpio_enable,
2215 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2216 term = nv->termination.scsi_bus_1_control;
2217 term |= nv->termination.scsi_bus_0_control << 2;
2218 term |= nv->termination.auto_term_support << 7;
2219 RD_REG_WORD(®->id_l); /* Flush PCI write */
2220 WRT_REG_WORD(®->gpio_data, term);
2222 RD_REG_WORD(®->id_l); /* Flush PCI write */
2224 /* ISP parameter word. */
2225 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2226 mb[1] = nv->isp_parameter;
2227 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2229 if (IS_ISP1x40(ha)) {
2230 /* clock rate - for qla1240 and older, only */
2231 mb[0] = MBC_SET_CLOCK_RATE;
2233 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2236 /* Firmware feature word. */
2237 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2238 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2239 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2240 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2241 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2243 /* Retry count and delay. */
2244 mb[0] = MBC_SET_RETRY_COUNT;
2245 mb[1] = nv->bus[0].retry_count;
2246 mb[2] = nv->bus[0].retry_delay;
2247 mb[6] = nv->bus[1].retry_count;
2248 mb[7] = nv->bus[1].retry_delay;
2249 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2250 BIT_1 | BIT_0, &mb[0]);
2252 /* ASYNC data setup time. */
2253 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2254 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2255 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2256 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2258 /* Active negation states. */
2259 mb[0] = MBC_SET_ACTIVE_NEGATION;
2261 if (nv->bus[0].config_2.req_ack_active_negation)
2263 if (nv->bus[0].config_2.data_line_active_negation)
2266 if (nv->bus[1].config_2.req_ack_active_negation)
2268 if (nv->bus[1].config_2.data_line_active_negation)
2270 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2272 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2273 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2274 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2277 mb[0] = MBC_SET_PCI_CONTROL;
2278 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2279 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2280 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2282 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2284 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2286 /* Selection timeout. */
2287 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2288 mb[1] = nv->bus[0].selection_timeout;
2289 mb[2] = nv->bus[1].selection_timeout;
2290 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2292 for (bus = 0; bus < ha->ports; bus++)
2293 status |= qla1280_config_bus(ha, bus);
2296 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2298 LEAVE("qla1280_nvram_config");
2303 * Get NVRAM data word
2304 * Calculates word position in NVRAM and calls request routine to
2305 * get the word from NVRAM.
2308 * ha = adapter block pointer.
2309 * address = NVRAM word address.
2315 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2320 nv_cmd = address << 16;
2321 nv_cmd |= NV_READ_OP;
2323 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2325 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2333 * Sends read command to NVRAM and gets data from NVRAM.
2336 * ha = adapter block pointer.
2337 * nv_cmd = Bit 26 = start bit
2338 * Bit 25, 24 = opcode
2339 * Bit 23-16 = address
2340 * Bit 15-0 = write data
2346 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2348 struct device_reg __iomem *reg = ha->iobase;
2353 /* Send command to NVRAM. */
2356 for (cnt = 0; cnt < 11; cnt++) {
2357 if (nv_cmd & BIT_31)
2358 qla1280_nv_write(ha, NV_DATA_OUT);
2360 qla1280_nv_write(ha, 0);
2364 /* Read data from NVRAM. */
2366 for (cnt = 0; cnt < 16; cnt++) {
2367 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2368 RD_REG_WORD(®->id_l); /* Flush PCI write */
2371 reg_data = RD_REG_WORD(®->nvram);
2372 if (reg_data & NV_DATA_IN)
2374 WRT_REG_WORD(®->nvram, NV_SELECT);
2375 RD_REG_WORD(®->id_l); /* Flush PCI write */
2379 /* Deselect chip. */
2381 WRT_REG_WORD(®->nvram, NV_DESELECT);
2382 RD_REG_WORD(®->id_l); /* Flush PCI write */
2389 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2391 struct device_reg __iomem *reg = ha->iobase;
2393 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2394 RD_REG_WORD(®->id_l); /* Flush PCI write */
2396 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2397 RD_REG_WORD(®->id_l); /* Flush PCI write */
2399 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2400 RD_REG_WORD(®->id_l); /* Flush PCI write */
2406 * Issue mailbox command and waits for completion.
2409 * ha = adapter block pointer.
2410 * mr = mailbox registers to load.
2411 * mb = data pointer for mailbox registers.
2414 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2420 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2422 struct device_reg __iomem *reg = ha->iobase;
2425 uint16_t *optr, *iptr;
2426 uint16_t __iomem *mptr;
2427 DECLARE_COMPLETION_ONSTACK(wait);
2429 ENTER("qla1280_mailbox_command");
2431 if (ha->mailbox_wait) {
2432 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2434 ha->mailbox_wait = &wait;
2437 * We really should start out by verifying that the mailbox is
2438 * available before starting sending the command data
2440 /* Load mailbox registers. */
2441 mptr = (uint16_t __iomem *) ®->mailbox0;
2443 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2445 WRT_REG_WORD(mptr, (*iptr));
2453 /* Issue set host interrupt command. */
2455 /* set up a timer just in case we're really jammed */
2456 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2457 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
2459 spin_unlock_irq(ha->host->host_lock);
2460 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2461 qla1280_debounce_register(®->istatus);
2463 wait_for_completion(&wait);
2464 del_timer_sync(&ha->mailbox_timer);
2466 spin_lock_irq(ha->host->host_lock);
2468 ha->mailbox_wait = NULL;
2470 /* Check for mailbox command timeout. */
2471 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2472 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2473 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2475 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2476 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2477 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2478 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2479 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2480 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2481 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2485 /* Load return mailbox registers. */
2487 iptr = (uint16_t *) &ha->mailbox_out[0];
2488 mr = MAILBOX_REGISTER_COUNT;
2489 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2491 if (ha->flags.reset_marker)
2492 qla1280_rst_aen(ha);
2495 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2496 "0x%x ****\n", mb[0]);
2498 LEAVE("qla1280_mailbox_command");
2504 * Polls ISP for interrupts.
2507 * ha = adapter block pointer.
2510 qla1280_poll(struct scsi_qla_host *ha)
2512 struct device_reg __iomem *reg = ha->iobase;
2516 /* ENTER("qla1280_poll"); */
2518 /* Check for pending interrupts. */
2519 data = RD_REG_WORD(®->istatus);
2520 if (data & RISC_INT)
2521 qla1280_isr(ha, &done_q);
2523 if (!ha->mailbox_wait) {
2524 if (ha->flags.reset_marker)
2525 qla1280_rst_aen(ha);
2528 if (!list_empty(&done_q))
2531 /* LEAVE("qla1280_poll"); */
2536 * Issue SCSI bus reset.
2539 * ha = adapter block pointer.
2540 * bus = SCSI bus number.
2546 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2548 uint16_t mb[MAILBOX_REGISTER_COUNT];
2549 uint16_t reset_delay;
2552 dprintk(3, "qla1280_bus_reset: entered\n");
2554 if (qla1280_verbose)
2555 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2558 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2559 mb[0] = MBC_BUS_RESET;
2560 mb[1] = reset_delay;
2561 mb[2] = (uint16_t) bus;
2562 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2565 if (ha->bus_settings[bus].failed_reset_count > 2)
2566 ha->bus_settings[bus].scsi_bus_dead = 1;
2567 ha->bus_settings[bus].failed_reset_count++;
2569 spin_unlock_irq(ha->host->host_lock);
2570 ssleep(reset_delay);
2571 spin_lock_irq(ha->host->host_lock);
2573 ha->bus_settings[bus].scsi_bus_dead = 0;
2574 ha->bus_settings[bus].failed_reset_count = 0;
2575 ha->bus_settings[bus].reset_marker = 0;
2576 /* Issue marker command. */
2577 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2581 * We should probably call qla1280_set_target_parameters()
2582 * here as well for all devices on the bus.
2586 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2588 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2594 * qla1280_device_reset
2595 * Issue bus device reset message to the target.
2598 * ha = adapter block pointer.
2599 * bus = SCSI BUS number.
2606 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2608 uint16_t mb[MAILBOX_REGISTER_COUNT];
2611 ENTER("qla1280_device_reset");
2613 mb[0] = MBC_ABORT_TARGET;
2614 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2616 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2618 /* Issue marker command. */
2619 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2622 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2624 LEAVE("qla1280_device_reset");
2629 * qla1280_abort_command
2630 * Abort command aborts a specified IOCB.
2633 * ha = adapter block pointer.
2634 * sp = SB structure pointer.
2640 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2642 uint16_t mb[MAILBOX_REGISTER_COUNT];
2643 unsigned int bus, target, lun;
2646 ENTER("qla1280_abort_command");
2648 bus = SCSI_BUS_32(sp->cmd);
2649 target = SCSI_TCN_32(sp->cmd);
2650 lun = SCSI_LUN_32(sp->cmd);
2652 sp->flags |= SRB_ABORT_PENDING;
2654 mb[0] = MBC_ABORT_COMMAND;
2655 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2656 mb[2] = handle >> 16;
2657 mb[3] = handle & 0xffff;
2658 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2661 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2662 sp->flags &= ~SRB_ABORT_PENDING;
2666 LEAVE("qla1280_abort_command");
2671 * qla1280_reset_adapter
2675 * ha = adapter block pointer.
2678 qla1280_reset_adapter(struct scsi_qla_host *ha)
2680 struct device_reg __iomem *reg = ha->iobase;
2682 ENTER("qla1280_reset_adapter");
2684 /* Disable ISP chip */
2685 ha->flags.online = 0;
2686 WRT_REG_WORD(®->ictrl, ISP_RESET);
2687 WRT_REG_WORD(®->host_cmd,
2688 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2689 RD_REG_WORD(®->id_l); /* Flush PCI write */
2691 LEAVE("qla1280_reset_adapter");
2695 * Issue marker command.
2696 * Function issues marker IOCB.
2699 * ha = adapter block pointer.
2700 * bus = SCSI BUS number
2703 * type = marker modifier
2706 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2708 struct mrk_entry *pkt;
2710 ENTER("qla1280_marker");
2712 /* Get request packet. */
2713 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2714 pkt->entry_type = MARKER_TYPE;
2715 pkt->lun = (uint8_t) lun;
2716 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2717 pkt->modifier = type;
2718 pkt->entry_status = 0;
2720 /* Issue command to ISP */
2721 qla1280_isp_cmd(ha);
2724 LEAVE("qla1280_marker");
2729 * qla1280_64bit_start_scsi
2730 * The start SCSI is responsible for building request packets on
2731 * request ring and modifying ISP input pointer.
2734 * ha = adapter block pointer.
2735 * sp = SB structure pointer.
2738 * 0 = success, was able to issue command.
2740 #ifdef QLA_64BIT_PTR
2742 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2744 struct device_reg __iomem *reg = ha->iobase;
2745 struct scsi_cmnd *cmd = sp->cmd;
2746 cmd_a64_entry_t *pkt;
2748 dma_addr_t dma_handle;
2755 ENTER("qla1280_64bit_start_scsi:");
2757 /* Calculate number of entries and segments required. */
2759 seg_cnt = scsi_dma_map(cmd);
2762 req_cnt += (seg_cnt - 2) / 5;
2763 if ((seg_cnt - 2) % 5)
2766 } else if (seg_cnt < 0) {
2771 if ((req_cnt + 2) >= ha->req_q_cnt) {
2772 /* Calculate number of free request entries. */
2773 cnt = RD_REG_WORD(®->mailbox4);
2774 if (ha->req_ring_index < cnt)
2775 ha->req_q_cnt = cnt - ha->req_ring_index;
2778 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2781 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2782 ha->req_q_cnt, seg_cnt);
2784 /* If room for request in request ring. */
2785 if ((req_cnt + 2) >= ha->req_q_cnt) {
2786 status = SCSI_MLQUEUE_HOST_BUSY;
2787 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
2788 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2793 /* Check for room in outstanding command list. */
2794 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2795 ha->outstanding_cmds[cnt] != NULL; cnt++);
2797 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2798 status = SCSI_MLQUEUE_HOST_BUSY;
2799 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2800 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2804 ha->outstanding_cmds[cnt] = sp;
2805 ha->req_q_cnt -= req_cnt;
2806 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2808 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2809 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2810 dprintk(2, " bus %i, target %i, lun %i\n",
2811 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2812 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2815 * Build command packet.
2817 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2819 pkt->entry_type = COMMAND_A64_TYPE;
2820 pkt->entry_count = (uint8_t) req_cnt;
2821 pkt->sys_define = (uint8_t) ha->req_ring_index;
2822 pkt->entry_status = 0;
2823 pkt->handle = cpu_to_le32(cnt);
2825 /* Zero out remaining portion of packet. */
2826 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2828 /* Set ISP command timeout. */
2829 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
2831 /* Set device target ID and LUN */
2832 pkt->lun = SCSI_LUN_32(cmd);
2833 pkt->target = SCSI_BUS_32(cmd) ?
2834 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2836 /* Enable simple tag queuing if device supports it. */
2837 if (cmd->device->simple_tags)
2838 pkt->control_flags |= cpu_to_le16(BIT_3);
2840 /* Load SCSI command packet. */
2841 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2842 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
2843 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2845 /* Set transfer direction. */
2846 dir = qla1280_data_direction(cmd);
2847 pkt->control_flags |= cpu_to_le16(dir);
2849 /* Set total data segment count. */
2850 pkt->dseg_count = cpu_to_le16(seg_cnt);
2853 * Load data segments.
2855 if (seg_cnt) { /* If data transfer. */
2856 struct scatterlist *sg, *s;
2857 int remseg = seg_cnt;
2859 sg = scsi_sglist(cmd);
2861 /* Setup packet address segment pointer. */
2862 dword_ptr = (u32 *)&pkt->dseg_0_address;
2864 /* Load command entry data segments. */
2865 for_each_sg(sg, s, seg_cnt, cnt) {
2869 dma_handle = sg_dma_address(s);
2871 cpu_to_le32(lower_32_bits(dma_handle));
2873 cpu_to_le32(upper_32_bits(dma_handle));
2874 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2875 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2876 cpu_to_le32(upper_32_bits(dma_handle)),
2877 cpu_to_le32(lower_32_bits(dma_handle)),
2878 cpu_to_le32(sg_dma_len(sg_next(s))));
2881 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2882 "command packet data - b %i, t %i, l %i \n",
2883 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2885 qla1280_dump_buffer(5, (char *)pkt,
2886 REQUEST_ENTRY_SIZE);
2889 * Build continuation packets.
2891 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2892 "remains\n", seg_cnt);
2894 while (remseg > 0) {
2895 /* Update sg start */
2897 /* Adjust ring index. */
2898 ha->req_ring_index++;
2899 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2900 ha->req_ring_index = 0;
2901 ha->request_ring_ptr =
2904 ha->request_ring_ptr++;
2906 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2908 /* Zero out packet. */
2909 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2911 /* Load packet defaults. */
2912 ((struct cont_a64_entry *) pkt)->entry_type =
2914 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2915 ((struct cont_a64_entry *) pkt)->sys_define =
2916 (uint8_t)ha->req_ring_index;
2917 /* Setup packet address segment pointer. */
2919 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2921 /* Load continuation entry data segments. */
2922 for_each_sg(sg, s, remseg, cnt) {
2925 dma_handle = sg_dma_address(s);
2927 cpu_to_le32(lower_32_bits(dma_handle));
2929 cpu_to_le32(upper_32_bits(dma_handle));
2931 cpu_to_le32(sg_dma_len(s));
2932 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2933 cpu_to_le32(upper_32_bits(dma_handle)),
2934 cpu_to_le32(lower_32_bits(dma_handle)),
2935 cpu_to_le32(sg_dma_len(s)));
2938 dprintk(5, "qla1280_64bit_start_scsi: "
2939 "continuation packet data - b %i, t "
2940 "%i, l %i \n", SCSI_BUS_32(cmd),
2941 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2942 qla1280_dump_buffer(5, (char *)pkt,
2943 REQUEST_ENTRY_SIZE);
2945 } else { /* No data transfer */
2946 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2947 "packet data - b %i, t %i, l %i \n",
2948 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2949 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2951 /* Adjust ring index. */
2952 ha->req_ring_index++;
2953 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2954 ha->req_ring_index = 0;
2955 ha->request_ring_ptr = ha->request_ring;
2957 ha->request_ring_ptr++;
2959 /* Set chip new ring index. */
2961 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
2962 sp->flags |= SRB_SENT;
2964 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
2968 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
2970 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
2974 #else /* !QLA_64BIT_PTR */
2977 * qla1280_32bit_start_scsi
2978 * The start SCSI is responsible for building request packets on
2979 * request ring and modifying ISP input pointer.
2981 * The Qlogic firmware interface allows every queue slot to have a SCSI
2982 * command and up to 4 scatter/gather (SG) entries. If we need more
2983 * than 4 SG entries, then continuation entries are used that can
2984 * hold another 7 entries each. The start routine determines if there
2985 * is eought empty slots then build the combination of requests to
2986 * fulfill the OS request.
2989 * ha = adapter block pointer.
2990 * sp = SCSI Request Block structure pointer.
2993 * 0 = success, was able to issue command.
2996 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2998 struct device_reg __iomem *reg = ha->iobase;
2999 struct scsi_cmnd *cmd = sp->cmd;
3000 struct cmd_entry *pkt;
3008 ENTER("qla1280_32bit_start_scsi");
3010 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3013 /* Calculate number of entries and segments required. */
3015 seg_cnt = scsi_dma_map(cmd);
3018 * if greater than four sg entries then we need to allocate
3019 * continuation entries
3022 req_cnt += (seg_cnt - 4) / 7;
3023 if ((seg_cnt - 4) % 7)
3026 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3027 cmd, seg_cnt, req_cnt);
3028 } else if (seg_cnt < 0) {
3033 if ((req_cnt + 2) >= ha->req_q_cnt) {
3034 /* Calculate number of free request entries. */
3035 cnt = RD_REG_WORD(®->mailbox4);
3036 if (ha->req_ring_index < cnt)
3037 ha->req_q_cnt = cnt - ha->req_ring_index;
3040 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3043 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3044 ha->req_q_cnt, seg_cnt);
3045 /* If room for request in request ring. */
3046 if ((req_cnt + 2) >= ha->req_q_cnt) {
3047 status = SCSI_MLQUEUE_HOST_BUSY;
3048 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3049 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3050 ha->req_q_cnt, req_cnt);
3054 /* Check for empty slot in outstanding command list. */
3055 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3056 ha->outstanding_cmds[cnt]; cnt++);
3058 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3059 status = SCSI_MLQUEUE_HOST_BUSY;
3060 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3061 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3065 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3066 ha->outstanding_cmds[cnt] = sp;
3067 ha->req_q_cnt -= req_cnt;
3070 * Build command packet.
3072 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3074 pkt->entry_type = COMMAND_TYPE;
3075 pkt->entry_count = (uint8_t) req_cnt;
3076 pkt->sys_define = (uint8_t) ha->req_ring_index;
3077 pkt->entry_status = 0;
3078 pkt->handle = cpu_to_le32(cnt);
3080 /* Zero out remaining portion of packet. */
3081 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3083 /* Set ISP command timeout. */
3084 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
3086 /* Set device target ID and LUN */
3087 pkt->lun = SCSI_LUN_32(cmd);
3088 pkt->target = SCSI_BUS_32(cmd) ?
3089 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3091 /* Enable simple tag queuing if device supports it. */
3092 if (cmd->device->simple_tags)
3093 pkt->control_flags |= cpu_to_le16(BIT_3);
3095 /* Load SCSI command packet. */
3096 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3097 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
3099 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3100 /* Set transfer direction. */
3101 dir = qla1280_data_direction(cmd);
3102 pkt->control_flags |= cpu_to_le16(dir);
3104 /* Set total data segment count. */
3105 pkt->dseg_count = cpu_to_le16(seg_cnt);
3108 * Load data segments.
3111 struct scatterlist *sg, *s;
3112 int remseg = seg_cnt;
3114 sg = scsi_sglist(cmd);
3116 /* Setup packet address segment pointer. */
3117 dword_ptr = &pkt->dseg_0_address;
3119 dprintk(3, "Building S/G data segments..\n");
3120 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3122 /* Load command entry data segments. */
3123 for_each_sg(sg, s, seg_cnt, cnt) {
3127 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3128 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3129 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3130 (lower_32_bits(sg_dma_address(s))),
3135 * Build continuation packets.
3137 dprintk(3, "S/G Building Continuation"
3138 "...seg_cnt=0x%x remains\n", seg_cnt);
3139 while (remseg > 0) {
3140 /* Continue from end point */
3142 /* Adjust ring index. */
3143 ha->req_ring_index++;
3144 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3145 ha->req_ring_index = 0;
3146 ha->request_ring_ptr =
3149 ha->request_ring_ptr++;
3151 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3153 /* Zero out packet. */
3154 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3156 /* Load packet defaults. */
3157 ((struct cont_entry *) pkt)->
3158 entry_type = CONTINUE_TYPE;
3159 ((struct cont_entry *) pkt)->entry_count = 1;
3161 ((struct cont_entry *) pkt)->sys_define =
3162 (uint8_t) ha->req_ring_index;
3164 /* Setup packet address segment pointer. */
3166 &((struct cont_entry *) pkt)->dseg_0_address;
3168 /* Load continuation entry data segments. */
3169 for_each_sg(sg, s, remseg, cnt) {
3173 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3175 cpu_to_le32(sg_dma_len(s));
3177 "S/G Segment Cont. phys_addr=0x%x, "
3179 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
3180 cpu_to_le32(sg_dma_len(s)));
3183 dprintk(5, "qla1280_32bit_start_scsi: "
3184 "continuation packet data - "
3185 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3186 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3187 qla1280_dump_buffer(5, (char *)pkt,
3188 REQUEST_ENTRY_SIZE);
3190 } else { /* No data transfer at all */
3191 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3192 "packet data - \n");
3193 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3195 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3196 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3197 REQUEST_ENTRY_SIZE);
3199 /* Adjust ring index. */
3200 ha->req_ring_index++;
3201 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3202 ha->req_ring_index = 0;
3203 ha->request_ring_ptr = ha->request_ring;
3205 ha->request_ring_ptr++;
3207 /* Set chip new ring index. */
3208 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3209 "for pending command\n");
3210 sp->flags |= SRB_SENT;
3212 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3216 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3218 LEAVE("qla1280_32bit_start_scsi");
3226 * Function is responsible for locking ring and
3227 * getting a zeroed out request packet.
3230 * ha = adapter block pointer.
3233 * 0 = failed to get slot.
3236 qla1280_req_pkt(struct scsi_qla_host *ha)
3238 struct device_reg __iomem *reg = ha->iobase;
3239 request_t *pkt = NULL;
3243 ENTER("qla1280_req_pkt");
3246 * This can be called from interrupt context, damn it!!!
3248 /* Wait for 30 seconds for slot. */
3249 for (timer = 15000000; timer; timer--) {
3250 if (ha->req_q_cnt > 0) {
3251 /* Calculate number of free request entries. */
3252 cnt = RD_REG_WORD(®->mailbox4);
3253 if (ha->req_ring_index < cnt)
3254 ha->req_q_cnt = cnt - ha->req_ring_index;
3257 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3260 /* Found empty request ring slot? */
3261 if (ha->req_q_cnt > 0) {
3263 pkt = ha->request_ring_ptr;
3265 /* Zero out packet. */
3266 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3269 * How can this be right when we have a ring
3272 /* Set system defined field. */
3273 pkt->sys_define = (uint8_t) ha->req_ring_index;
3275 /* Set entry count. */
3276 pkt->entry_count = 1;
3283 /* Check for pending interrupts. */
3288 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3290 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3297 * Function is responsible for modifying ISP input pointer.
3298 * Releases ring lock.
3301 * ha = adapter block pointer.
3304 qla1280_isp_cmd(struct scsi_qla_host *ha)
3306 struct device_reg __iomem *reg = ha->iobase;
3308 ENTER("qla1280_isp_cmd");
3310 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3311 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3312 REQUEST_ENTRY_SIZE);
3314 /* Adjust ring index. */
3315 ha->req_ring_index++;
3316 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3317 ha->req_ring_index = 0;
3318 ha->request_ring_ptr = ha->request_ring;
3320 ha->request_ring_ptr++;
3323 * Update request index to mailbox4 (Request Queue In).
3325 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3327 LEAVE("qla1280_isp_cmd");
3330 /****************************************************************************/
3331 /* Interrupt Service Routine. */
3332 /****************************************************************************/
3334 /****************************************************************************
3336 * Calls I/O done on command completion.
3339 * ha = adapter block pointer.
3340 * done_q = done queue.
3341 ****************************************************************************/
3343 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3345 struct device_reg __iomem *reg = ha->iobase;
3346 struct response *pkt;
3347 struct srb *sp = NULL;
3348 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3353 ENTER("qla1280_isr");
3355 istatus = RD_REG_WORD(®->istatus);
3356 if (!(istatus & (RISC_INT | PCI_INT)))
3359 /* Save mailbox register 5 */
3360 mailbox[5] = RD_REG_WORD(®->mailbox5);
3362 /* Check for mailbox interrupt. */
3364 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3366 if (mailbox[0] & BIT_0) {
3367 /* Get mailbox data. */
3368 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3371 *wptr++ = RD_REG_WORD(®->mailbox0);
3372 *wptr++ = RD_REG_WORD(®->mailbox1);
3373 *wptr = RD_REG_WORD(®->mailbox2);
3374 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3376 *wptr++ = RD_REG_WORD(®->mailbox3);
3377 *wptr++ = RD_REG_WORD(®->mailbox4);
3379 *wptr++ = RD_REG_WORD(®->mailbox6);
3380 *wptr = RD_REG_WORD(®->mailbox7);
3383 /* Release mailbox registers. */
3385 WRT_REG_WORD(®->semaphore, 0);
3386 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3388 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3391 /* Handle asynchronous event */
3392 switch (mailbox[0]) {
3393 case MBA_SCSI_COMPLETION: /* Response completion */
3394 dprintk(5, "qla1280_isr: mailbox SCSI response "
3397 if (ha->flags.online) {
3398 /* Get outstanding command index. */
3399 index = mailbox[2] << 16 | mailbox[1];
3401 /* Validate handle. */
3402 if (index < MAX_OUTSTANDING_COMMANDS)
3403 sp = ha->outstanding_cmds[index];
3408 /* Free outstanding command slot. */
3409 ha->outstanding_cmds[index] = NULL;
3411 /* Save ISP completion status */
3412 CMD_RESULT(sp->cmd) = 0;
3413 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3415 /* Place block on done queue */
3416 list_add_tail(&sp->list, done_q);
3419 * If we get here we have a real problem!
3422 "qla1280: ISP invalid handle\n");
3427 case MBA_BUS_RESET: /* SCSI Bus Reset */
3428 ha->flags.reset_marker = 1;
3429 index = mailbox[6] & BIT_0;
3430 ha->bus_settings[index].reset_marker = 1;
3432 printk(KERN_DEBUG "qla1280_isr(): index %i "
3433 "asynchronous BUS_RESET\n", index);
3436 case MBA_SYSTEM_ERR: /* System Error */
3438 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3439 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3443 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3445 "qla1280: ISP Request Transfer Error\n");
3448 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3450 "qla1280: ISP Response Transfer Error\n");
3453 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3454 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3457 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3459 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3462 case MBA_DEVICE_RESET: /* Bus Device Reset */
3463 printk(KERN_INFO "qla1280_isr(): asynchronous "
3464 "BUS_DEVICE_RESET\n");
3466 ha->flags.reset_marker = 1;
3467 index = mailbox[6] & BIT_0;
3468 ha->bus_settings[index].reset_marker = 1;
3471 case MBA_BUS_MODE_CHANGE:
3473 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3477 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3478 if (mailbox[0] < MBA_ASYNC_EVENT) {
3480 memcpy((uint16_t *) ha->mailbox_out, wptr,
3481 MAILBOX_REGISTER_COUNT *
3484 if(ha->mailbox_wait != NULL)
3485 complete(ha->mailbox_wait);
3490 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3494 * We will receive interrupts during mailbox testing prior to
3495 * the card being marked online, hence the double check.
3497 if (!(ha->flags.online && !ha->mailbox_wait)) {
3498 dprintk(2, "qla1280_isr: Response pointer Error\n");
3502 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3505 while (ha->rsp_ring_index != mailbox[5]) {
3506 pkt = ha->response_ring_ptr;
3508 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3509 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3510 dprintk(5,"qla1280_isr: response packet data\n");
3511 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3513 if (pkt->entry_type == STATUS_TYPE) {
3514 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3515 || pkt->comp_status || pkt->entry_status) {
3516 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3517 "0x%x mailbox[5] = 0x%x, comp_status "
3518 "= 0x%x, scsi_status = 0x%x\n",
3519 ha->rsp_ring_index, mailbox[5],
3520 le16_to_cpu(pkt->comp_status),
3521 le16_to_cpu(pkt->scsi_status));
3524 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3525 "0x%x, mailbox[5] = 0x%x\n",
3526 ha->rsp_ring_index, mailbox[5]);
3527 dprintk(2, "qla1280_isr: response packet data\n");
3528 qla1280_dump_buffer(2, (char *)pkt,
3529 RESPONSE_ENTRY_SIZE);
3532 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3533 dprintk(2, "status: Cmd %p, handle %i\n",
3534 ha->outstanding_cmds[pkt->handle]->cmd,
3536 if (pkt->entry_type == STATUS_TYPE)
3537 qla1280_status_entry(ha, pkt, done_q);
3539 qla1280_error_entry(ha, pkt, done_q);
3540 /* Adjust ring index. */
3541 ha->rsp_ring_index++;
3542 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3543 ha->rsp_ring_index = 0;
3544 ha->response_ring_ptr = ha->response_ring;
3546 ha->response_ring_ptr++;
3547 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3552 LEAVE("qla1280_isr");
3557 * Processes asynchronous reset.
3560 * ha = adapter block pointer.
3563 qla1280_rst_aen(struct scsi_qla_host *ha)
3567 ENTER("qla1280_rst_aen");
3569 if (ha->flags.online && !ha->flags.reset_active &&
3570 !ha->flags.abort_isp_active) {
3571 ha->flags.reset_active = 1;
3572 while (ha->flags.reset_marker) {
3573 /* Issue marker command. */
3574 ha->flags.reset_marker = 0;
3575 for (bus = 0; bus < ha->ports &&
3576 !ha->flags.reset_marker; bus++) {
3577 if (ha->bus_settings[bus].reset_marker) {
3578 ha->bus_settings[bus].reset_marker = 0;
3579 qla1280_marker(ha, bus, 0, 0,
3586 LEAVE("qla1280_rst_aen");
3591 * qla1280_status_entry
3592 * Processes received ISP status entry.
3595 * ha = adapter block pointer.
3596 * pkt = entry pointer.
3597 * done_q = done queue.
3600 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3601 struct list_head *done_q)
3605 struct scsi_cmnd *cmd;
3606 uint32_t handle = le32_to_cpu(pkt->handle);
3607 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3608 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3610 ENTER("qla1280_status_entry");
3612 /* Validate handle. */
3613 if (handle < MAX_OUTSTANDING_COMMANDS)
3614 sp = ha->outstanding_cmds[handle];
3619 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3623 /* Free outstanding command slot. */
3624 ha->outstanding_cmds[handle] = NULL;
3628 if (comp_status || scsi_status) {
3629 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3630 "0x%x, handle = 0x%x\n", comp_status,
3631 scsi_status, handle);
3634 /* Target busy or queue full */
3635 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3636 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3637 CMD_RESULT(cmd) = scsi_status & 0xff;
3640 /* Save ISP completion status */
3641 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3643 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3644 if (comp_status != CS_ARS_FAILED) {
3645 uint16_t req_sense_length =
3646 le16_to_cpu(pkt->req_sense_length);
3647 if (req_sense_length < CMD_SNSLEN(cmd))
3648 sense_sz = req_sense_length;
3651 * scsi_cmnd->sense_buffer is
3652 * 64 bytes, why only copy 63?
3653 * This looks wrong! /Jes
3655 sense_sz = CMD_SNSLEN(cmd) - 1;
3657 memcpy(cmd->sense_buffer,
3658 &pkt->req_sense_data, sense_sz);
3661 memset(cmd->sense_buffer + sense_sz, 0,
3662 SCSI_SENSE_BUFFERSIZE - sense_sz);
3664 dprintk(2, "qla1280_status_entry: Check "
3665 "condition Sense data, b %i, t %i, "
3666 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3669 qla1280_dump_buffer(2,
3670 (char *)cmd->sense_buffer,
3675 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3677 /* Place command on done queue. */
3678 list_add_tail(&sp->list, done_q);
3680 LEAVE("qla1280_status_entry");
3684 * qla1280_error_entry
3685 * Processes error entry.
3688 * ha = adapter block pointer.
3689 * pkt = entry pointer.
3690 * done_q = done queue.
3693 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3694 struct list_head *done_q)
3697 uint32_t handle = le32_to_cpu(pkt->handle);
3699 ENTER("qla1280_error_entry");
3701 if (pkt->entry_status & BIT_3)
3702 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3703 else if (pkt->entry_status & BIT_2)
3704 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3705 else if (pkt->entry_status & BIT_1)
3706 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3708 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3710 /* Validate handle. */
3711 if (handle < MAX_OUTSTANDING_COMMANDS)
3712 sp = ha->outstanding_cmds[handle];
3717 /* Free outstanding command slot. */
3718 ha->outstanding_cmds[handle] = NULL;
3720 /* Bad payload or header */
3721 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3722 /* Bad payload or header, set error status. */
3723 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3724 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3725 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3726 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3728 /* Set error status. */
3729 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3732 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3734 /* Place command on done queue. */
3735 list_add_tail(&sp->list, done_q);
3737 #ifdef QLA_64BIT_PTR
3738 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3739 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3743 LEAVE("qla1280_error_entry");
3748 * Resets ISP and aborts all outstanding commands.
3751 * ha = adapter block pointer.
3757 qla1280_abort_isp(struct scsi_qla_host *ha)
3759 struct device_reg __iomem *reg = ha->iobase;
3765 ENTER("qla1280_abort_isp");
3767 if (ha->flags.abort_isp_active || !ha->flags.online)
3770 ha->flags.abort_isp_active = 1;
3772 /* Disable ISP interrupts. */
3773 qla1280_disable_intrs(ha);
3774 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3775 RD_REG_WORD(®->id_l);
3777 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3779 /* Dequeue all commands in outstanding command list. */
3780 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3781 struct scsi_cmnd *cmd;
3782 sp = ha->outstanding_cmds[cnt];
3785 CMD_RESULT(cmd) = DID_RESET << 16;
3786 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
3787 ha->outstanding_cmds[cnt] = NULL;
3788 list_add_tail(&sp->list, &ha->done_q);
3794 status = qla1280_load_firmware(ha);
3798 /* Setup adapter based on NVRAM parameters. */
3799 qla1280_nvram_config (ha);
3801 status = qla1280_init_rings(ha);
3805 /* Issue SCSI reset. */
3806 for (bus = 0; bus < ha->ports; bus++)
3807 qla1280_bus_reset(ha, bus);
3809 ha->flags.abort_isp_active = 0;
3813 "qla1280: ISP error recovery failed, board disabled");
3814 qla1280_reset_adapter(ha);
3815 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3818 LEAVE("qla1280_abort_isp");
3824 * qla1280_debounce_register
3825 * Debounce register.
3828 * port = register address.
3834 qla1280_debounce_register(volatile u16 __iomem * addr)
3839 ret = RD_REG_WORD(addr);
3840 ret2 = RD_REG_WORD(addr);
3847 ret = RD_REG_WORD(addr);
3848 ret2 = RD_REG_WORD(addr);
3849 } while (ret != ret2);
3855 /************************************************************************
3856 * qla1280_check_for_dead_scsi_bus *
3858 * This routine checks for a dead SCSI bus *
3859 ************************************************************************/
3860 #define SET_SXP_BANK 0x0100
3861 #define SCSI_PHASE_INVALID 0x87FF
3863 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3865 uint16_t config_reg, scsi_control;
3866 struct device_reg __iomem *reg = ha->iobase;
3868 if (ha->bus_settings[bus].scsi_bus_dead) {
3869 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3870 config_reg = RD_REG_WORD(®->cfg_1);
3871 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
3872 scsi_control = RD_REG_WORD(®->scsiControlPins);
3873 WRT_REG_WORD(®->cfg_1, config_reg);
3874 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
3876 if (scsi_control == SCSI_PHASE_INVALID) {
3877 ha->bus_settings[bus].scsi_bus_dead = 1;
3878 return 1; /* bus is dead */
3880 ha->bus_settings[bus].scsi_bus_dead = 0;
3881 ha->bus_settings[bus].failed_reset_count = 0;
3884 return 0; /* bus is not dead */
3888 qla1280_get_target_parameters(struct scsi_qla_host *ha,
3889 struct scsi_device *device)
3891 uint16_t mb[MAILBOX_REGISTER_COUNT];
3892 int bus, target, lun;
3894 bus = device->channel;
3895 target = device->id;
3899 mb[0] = MBC_GET_TARGET_PARAMETERS;
3900 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3902 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3905 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3908 printk(KERN_CONT " Sync: period %d, offset %d",
3909 (mb[3] & 0xff), (mb[3] >> 8));
3911 printk(KERN_CONT ", Wide");
3912 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3913 printk(KERN_CONT ", DT");
3915 printk(KERN_CONT " Async");
3917 if (device->simple_tags)
3918 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);
3919 printk(KERN_CONT "\n");
3925 __qla1280_dump_buffer(char *b, int size)
3930 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3931 "Bh Ch Dh Eh Fh\n");
3932 printk(KERN_DEBUG "---------------------------------------------"
3933 "------------------\n");
3935 for (cnt = 0; cnt < size;) {
3938 printk("0x%02x", c);
3949 /**************************************************************************
3950 * ql1280_print_scsi_cmd
3952 **************************************************************************/
3954 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
3956 struct scsi_qla_host *ha;
3957 struct Scsi_Host *host = CMD_HOST(cmd);
3959 /* struct scatterlist *sg; */
3962 ha = (struct scsi_qla_host *)host->hostdata;
3964 sp = (struct srb *)CMD_SP(cmd);
3965 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
3966 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
3967 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
3970 for (i = 0; i < cmd->cmd_len; i++) {
3971 printk("0x%02x ", cmd->cmnd[i]);
3973 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
3974 printk(" request buffer=0x%p, request buffer len=0x%x\n",
3975 scsi_sglist(cmd), scsi_bufflen(cmd));
3978 sg = (struct scatterlist *) cmd->request_buffer;
3979 printk(" SG buffer: \n");
3980 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
3982 printk(" tag=%d, transfersize=0x%x \n",
3983 scsi_cmd_to_rq(cmd)->tag, cmd->transfersize);
3984 printk(" SP=0x%p\n", CMD_SP(cmd));
3985 printk(" underflow size = 0x%x, direction=0x%x\n",
3986 cmd->underflow, cmd->sc_data_direction);
3989 /**************************************************************************
3990 * ql1280_dump_device
3992 **************************************************************************/
3994 ql1280_dump_device(struct scsi_qla_host *ha)
3997 struct scsi_cmnd *cp;
4001 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4003 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4004 if ((sp = ha->outstanding_cmds[i]) == NULL)
4006 if ((cp = sp->cmd) == NULL)
4008 qla1280_print_scsi_cmd(1, cp);
4023 struct setup_tokens {
4028 static struct setup_tokens setup_token[] __initdata =
4030 { "nvram", TOKEN_NVRAM },
4031 { "sync", TOKEN_SYNC },
4032 { "wide", TOKEN_WIDE },
4033 { "ppr", TOKEN_PPR },
4034 { "verbose", TOKEN_VERBOSE },
4035 { "debug", TOKEN_DEBUG },
4039 /**************************************************************************
4042 * Handle boot parameters. This really needs to be changed so one
4043 * can specify per adapter parameters.
4044 **************************************************************************/
4046 qla1280_setup(char *s)
4054 while (cp && (ptr = strchr(cp, ':'))) {
4056 if (!strcmp(ptr, "yes")) {
4059 } else if (!strcmp(ptr, "no")) {
4063 val = simple_strtoul(ptr, &ptr, 0);
4065 switch ((toke = qla1280_get_token(cp))) {
4068 driver_setup.no_nvram = 1;
4072 driver_setup.no_sync = 1;
4073 else if (val != 0x10000)
4074 driver_setup.sync_mask = val;
4078 driver_setup.no_wide = 1;
4079 else if (val != 0x10000)
4080 driver_setup.wide_mask = val;
4084 driver_setup.no_ppr = 1;
4085 else if (val != 0x10000)
4086 driver_setup.ppr_mask = val;
4089 qla1280_verbose = val;
4092 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4096 cp = strchr(ptr, ';');
4108 qla1280_get_token(char *str)
4114 sep = strchr(str, ':');
4117 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
4118 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4119 ret = setup_token[i].val;
4129 static struct scsi_host_template qla1280_driver_template = {
4130 .module = THIS_MODULE,
4131 .proc_name = "qla1280",
4132 .name = "Qlogic ISP 1280/12160",
4133 .info = qla1280_info,
4134 .slave_configure = qla1280_slave_configure,
4135 .queuecommand = qla1280_queuecommand,
4136 .eh_abort_handler = qla1280_eh_abort,
4137 .eh_device_reset_handler= qla1280_eh_device_reset,
4138 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4139 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4140 .bios_param = qla1280_biosparam,
4141 .can_queue = MAX_OUTSTANDING_COMMANDS,
4143 .sg_tablesize = SG_ALL,
4148 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4150 int devnum = id->driver_data;
4151 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4152 struct Scsi_Host *host;
4153 struct scsi_qla_host *ha;
4154 int error = -ENODEV;
4156 /* Bypass all AMI SUBSYS VENDOR IDs */
4157 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4159 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4163 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4164 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4166 if (pci_enable_device(pdev)) {
4168 "qla1280: Failed to enabled pci device, aborting.\n");
4172 pci_set_master(pdev);
4175 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4178 "qla1280: Failed to register host, aborting.\n");
4179 goto error_disable_device;
4182 ha = (struct scsi_qla_host *)host->hostdata;
4183 memset(ha, 0, sizeof(struct scsi_qla_host));
4186 ha->devnum = devnum; /* specifies microcode load address */
4188 #ifdef QLA_64BIT_PTR
4189 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
4190 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4191 printk(KERN_WARNING "scsi(%li): Unable to set a "
4192 "suitable DMA mask - aborting\n", ha->host_no);
4194 goto error_put_host;
4197 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4200 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4201 printk(KERN_WARNING "scsi(%li): Unable to set a "
4202 "suitable DMA mask - aborting\n", ha->host_no);
4204 goto error_put_host;
4208 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
4209 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4210 &ha->request_dma, GFP_KERNEL);
4211 if (!ha->request_ring) {
4212 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4213 goto error_put_host;
4216 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
4217 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4218 &ha->response_dma, GFP_KERNEL);
4219 if (!ha->response_ring) {
4220 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4221 goto error_free_request_ring;
4224 ha->ports = bdp->numPorts;
4227 ha->host_no = host->host_no;
4229 host->irq = pdev->irq;
4230 host->max_channel = bdp->numPorts - 1;
4231 host->max_lun = MAX_LUNS - 1;
4232 host->max_id = MAX_TARGETS;
4233 host->max_sectors = 1024;
4234 host->unique_id = host->host_no;
4238 #if MEMORY_MAPPED_IO
4239 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
4241 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4242 goto error_free_response_ring;
4245 host->base = (unsigned long)ha->mmpbase;
4246 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4248 host->io_port = pci_resource_start(ha->pdev, 0);
4249 if (!request_region(host->io_port, 0xff, "qla1280")) {
4250 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4251 "0x%04lx-0x%04lx - already in use\n",
4252 host->io_port, host->io_port + 0xff);
4253 goto error_free_response_ring;
4256 ha->iobase = (struct device_reg *)host->io_port;
4259 INIT_LIST_HEAD(&ha->done_q);
4261 /* Disable ISP interrupts. */
4262 qla1280_disable_intrs(ha);
4264 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
4266 printk("qla1280 : Failed to reserve interrupt %d already "
4267 "in use\n", pdev->irq);
4268 goto error_release_region;
4271 /* load the F/W, read paramaters, and init the H/W */
4272 if (qla1280_initialize_adapter(ha)) {
4273 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4274 goto error_free_irq;
4277 /* set our host ID (need to do something about our two IDs) */
4278 host->this_id = ha->bus_settings[0].id;
4280 pci_set_drvdata(pdev, host);
4282 error = scsi_add_host(host, &pdev->dev);
4284 goto error_disable_adapter;
4285 scsi_scan_host(host);
4289 error_disable_adapter:
4290 qla1280_disable_intrs(ha);
4292 free_irq(pdev->irq, ha);
4293 error_release_region:
4294 #if MEMORY_MAPPED_IO
4295 iounmap(ha->mmpbase);
4297 release_region(host->io_port, 0xff);
4299 error_free_response_ring:
4300 dma_free_coherent(&ha->pdev->dev,
4301 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4302 ha->response_ring, ha->response_dma);
4303 error_free_request_ring:
4304 dma_free_coherent(&ha->pdev->dev,
4305 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4306 ha->request_ring, ha->request_dma);
4308 scsi_host_put(host);
4309 error_disable_device:
4310 pci_disable_device(pdev);
4317 qla1280_remove_one(struct pci_dev *pdev)
4319 struct Scsi_Host *host = pci_get_drvdata(pdev);
4320 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4322 scsi_remove_host(host);
4324 qla1280_disable_intrs(ha);
4326 free_irq(pdev->irq, ha);
4328 #if MEMORY_MAPPED_IO
4329 iounmap(ha->mmpbase);
4331 release_region(host->io_port, 0xff);
4334 dma_free_coherent(&ha->pdev->dev,
4335 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4336 ha->request_ring, ha->request_dma);
4337 dma_free_coherent(&ha->pdev->dev,
4338 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4339 ha->response_ring, ha->response_dma);
4341 pci_disable_device(pdev);
4343 scsi_host_put(host);
4346 static struct pci_driver qla1280_pci_driver = {
4348 .id_table = qla1280_pci_tbl,
4349 .probe = qla1280_probe_one,
4350 .remove = qla1280_remove_one,
4356 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4358 "qla1280: struct srb too big, aborting\n");
4364 * If we are called as a module, the qla1280 pointer may not be null
4365 * and it would point to our bootup string, just like on the lilo
4366 * command line. IF not NULL, then process this config string with
4370 * To add options at boot time add a line to your lilo.conf file like:
4371 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4372 * which will result in the first four devices on the first two
4373 * controllers being set to a tagged queue depth of 32.
4376 qla1280_setup(qla1280);
4379 return pci_register_driver(&qla1280_pci_driver);
4387 pci_unregister_driver(&qla1280_pci_driver);
4388 /* release any allocated firmware images */
4389 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4390 release_firmware(qla1280_fw_tbl[i].fw);
4391 qla1280_fw_tbl[i].fw = NULL;
4395 module_init(qla1280_init);
4396 module_exit(qla1280_exit);
4398 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4399 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4400 MODULE_LICENSE("GPL");
4401 MODULE_FIRMWARE("qlogic/1040.bin");
4402 MODULE_FIRMWARE("qlogic/1280.bin");
4403 MODULE_FIRMWARE("qlogic/12160.bin");
4404 MODULE_VERSION(QLA1280_VERSION);