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 **************************************************************************/
692 static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
694 struct Scsi_Host *host = cmd->device->host;
695 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
696 struct srb *sp = (struct srb *)CMD_SP(cmd);
702 CMD_HANDLE(cmd) = (unsigned char *)NULL;
704 qla1280_print_scsi_cmd(5, cmd);
708 * Using 64 bit commands if the PCI bridge doesn't support it is a
709 * bit wasteful, however this should really only happen if one's
710 * PCI controller is completely broken, like the BCM1250. For
711 * sane hardware this is not an issue.
713 status = qla1280_64bit_start_scsi(ha, sp);
715 status = qla1280_32bit_start_scsi(ha, sp);
720 static DEF_SCSI_QCMD(qla1280_queuecommand)
730 static void qla1280_mailbox_timeout(struct timer_list *t)
732 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
733 struct device_reg __iomem *reg;
736 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
737 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
738 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
739 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
740 complete(ha->mailbox_wait);
744 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
745 struct completion *wait)
748 struct scsi_cmnd *cmd = sp->cmd;
750 spin_unlock_irq(ha->host->host_lock);
751 wait_for_completion_timeout(wait, 4*HZ);
752 spin_lock_irq(ha->host->host_lock);
754 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
762 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
764 DECLARE_COMPLETION_ONSTACK(wait);
767 return _qla1280_wait_for_single_command(ha, sp, &wait);
771 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
776 struct scsi_cmnd *cmd;
781 * Wait for all commands with the designated bus/target
782 * to be completed by the firmware
784 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
785 sp = ha->outstanding_cmds[cnt];
789 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
791 if (target >= 0 && SCSI_TCN_32(cmd) != target)
794 status = qla1280_wait_for_single_command(ha, sp);
795 if (status == FAILED)
802 /**************************************************************************
803 * qla1280_error_action
804 * The function will attempt to perform a specified error action and
805 * wait for the results (or time out).
808 * cmd = Linux SCSI command packet of the command that cause the
810 * action = error action to take (see action_t)
815 **************************************************************************/
817 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
819 struct scsi_qla_host *ha;
820 int bus, target, lun;
825 int wait_for_target = -1;
826 DECLARE_COMPLETION_ONSTACK(wait);
828 ENTER("qla1280_error_action");
830 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
831 sp = (struct srb *)CMD_SP(cmd);
832 bus = SCSI_BUS_32(cmd);
833 target = SCSI_TCN_32(cmd);
834 lun = SCSI_LUN_32(cmd);
836 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
837 RD_REG_WORD(&ha->iobase->istatus));
839 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
840 RD_REG_WORD(&ha->iobase->host_cmd),
841 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
844 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
845 "Handle=0x%p, action=0x%x\n",
846 ha->host_no, cmd, CMD_HANDLE(cmd), action);
849 * Check to see if we have the command in the outstanding_cmds[]
850 * array. If not then it must have completed before this error
851 * action was initiated. If the error_action isn't ABORT_COMMAND
852 * then the driver must proceed with the requested action.
855 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
856 if (sp == ha->outstanding_cmds[i]) {
858 sp->wait = &wait; /* we'll wait for it to complete */
863 if (found < 0) { /* driver doesn't have command */
865 if (qla1280_verbose) {
867 "scsi(%ld:%d:%d:%d): specified command has "
868 "already completed.\n", ha->host_no, bus,
876 dprintk(1, "qla1280: RISC aborting command\n");
878 * The abort might fail due to race when the host_lock
879 * is released to issue the abort. As such, we
880 * don't bother to check the return status.
883 qla1280_abort_command(ha, sp, found);
889 "scsi(%ld:%d:%d:%d): Queueing device reset "
890 "command.\n", ha->host_no, bus, target, lun);
891 if (qla1280_device_reset(ha, bus, target) == 0) {
892 /* issued device reset, set wait conditions */
894 wait_for_target = target;
900 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
901 "reset.\n", ha->host_no, bus);
902 if (qla1280_bus_reset(ha, bus) == 0) {
903 /* issued bus reset, set wait conditions */
910 if (qla1280_verbose) {
912 "scsi(%ld): Issued ADAPTER RESET\n",
914 printk(KERN_INFO "scsi(%ld): I/O processing will "
915 "continue automatically\n", ha->host_no);
917 ha->flags.reset_active = 1;
919 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
923 ha->flags.reset_active = 0;
927 * At this point, the host_lock has been released and retaken
928 * by the issuance of the mailbox command.
929 * Wait for the command passed in by the mid-layer if it
930 * was found by the driver. It might have been returned
931 * between eh recovery steps, hence the check of the "found"
936 result = _qla1280_wait_for_single_command(ha, sp, &wait);
938 if (action == ABORT_COMMAND && result != SUCCESS) {
940 "scsi(%li:%i:%i:%i): "
941 "Unable to abort command!\n",
942 ha->host_no, bus, target, lun);
946 * If the command passed in by the mid-layer has been
947 * returned by the board, then wait for any additional
948 * commands which are supposed to complete based upon
951 * All commands are unconditionally returned during a
952 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
955 if (result == SUCCESS && wait_for_bus >= 0) {
956 result = qla1280_wait_for_pending_commands(ha,
957 wait_for_bus, wait_for_target);
960 dprintk(1, "RESET returning %d\n", result);
962 LEAVE("qla1280_error_action");
966 /**************************************************************************
968 * Abort the specified SCSI command(s).
969 **************************************************************************/
971 qla1280_eh_abort(struct scsi_cmnd * cmd)
975 spin_lock_irq(cmd->device->host->host_lock);
976 rc = qla1280_error_action(cmd, ABORT_COMMAND);
977 spin_unlock_irq(cmd->device->host->host_lock);
982 /**************************************************************************
983 * qla1280_device_reset
984 * Reset the specified SCSI device
985 **************************************************************************/
987 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
991 spin_lock_irq(cmd->device->host->host_lock);
992 rc = qla1280_error_action(cmd, DEVICE_RESET);
993 spin_unlock_irq(cmd->device->host->host_lock);
998 /**************************************************************************
1000 * Reset the specified bus.
1001 **************************************************************************/
1003 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1007 spin_lock_irq(cmd->device->host->host_lock);
1008 rc = qla1280_error_action(cmd, BUS_RESET);
1009 spin_unlock_irq(cmd->device->host->host_lock);
1014 /**************************************************************************
1015 * qla1280_adapter_reset
1016 * Reset the specified adapter (both channels)
1017 **************************************************************************/
1019 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1023 spin_lock_irq(cmd->device->host->host_lock);
1024 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1025 spin_unlock_irq(cmd->device->host->host_lock);
1031 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1032 sector_t capacity, int geom[])
1034 int heads, sectors, cylinders;
1038 cylinders = (unsigned long)capacity / (heads * sectors);
1039 if (cylinders > 1024) {
1042 cylinders = (unsigned long)capacity / (heads * sectors);
1043 /* if (cylinders > 1023)
1044 cylinders = 1023; */
1049 geom[2] = cylinders;
1055 /* disable risc and host interrupts */
1057 qla1280_disable_intrs(struct scsi_qla_host *ha)
1059 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1060 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1063 /* enable risc and host interrupts */
1065 qla1280_enable_intrs(struct scsi_qla_host *ha)
1067 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1068 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1071 /**************************************************************************
1072 * qla1280_intr_handler
1073 * Handles the H/W interrupt
1074 **************************************************************************/
1076 qla1280_intr_handler(int irq, void *dev_id)
1078 struct scsi_qla_host *ha;
1079 struct device_reg __iomem *reg;
1083 ENTER_INTR ("qla1280_intr_handler");
1084 ha = (struct scsi_qla_host *)dev_id;
1086 spin_lock(ha->host->host_lock);
1091 qla1280_disable_intrs(ha);
1093 data = qla1280_debounce_register(®->istatus);
1094 /* Check for pending interrupts. */
1095 if (data & RISC_INT) {
1096 qla1280_isr(ha, &ha->done_q);
1099 if (!list_empty(&ha->done_q))
1102 spin_unlock(ha->host->host_lock);
1104 qla1280_enable_intrs(ha);
1106 LEAVE_INTR("qla1280_intr_handler");
1107 return IRQ_RETVAL(handled);
1112 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1115 uint16_t mb[MAILBOX_REGISTER_COUNT];
1121 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1123 /* Set Target Parameters. */
1124 mb[0] = MBC_SET_TARGET_PARAMETERS;
1125 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1126 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1127 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1128 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1129 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1130 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1131 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1132 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1133 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1135 if (IS_ISP1x160(ha)) {
1136 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1137 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1138 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1139 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1142 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1144 mb[3] |= nv->bus[bus].target[target].sync_period;
1146 status = qla1280_mailbox_command(ha, mr, mb);
1148 /* Set Device Queue Parameters. */
1149 for (lun = 0; lun < MAX_LUNS; lun++) {
1150 mb[0] = MBC_SET_DEVICE_QUEUE;
1151 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1153 mb[2] = nv->bus[bus].max_queue_depth;
1154 mb[3] = nv->bus[bus].target[target].execution_throttle;
1155 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1159 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1160 "qla1280_set_target_parameters() failed\n",
1161 ha->host_no, bus, target);
1166 /**************************************************************************
1167 * qla1280_slave_configure
1170 * Determines the queue depth for a given device. There are two ways
1171 * a queue depth can be obtained for a tagged queueing device. One
1172 * way is the default queue depth which is determined by whether
1173 * If it is defined, then it is used
1174 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1175 * default queue depth (dependent on the number of hardware SCBs).
1176 **************************************************************************/
1178 qla1280_slave_configure(struct scsi_device *device)
1180 struct scsi_qla_host *ha;
1181 int default_depth = 3;
1182 int bus = device->channel;
1183 int target = device->id;
1186 unsigned long flags;
1188 ha = (struct scsi_qla_host *)device->host->hostdata;
1191 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1194 if (device->tagged_supported &&
1195 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1196 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1198 scsi_change_queue_depth(device, default_depth);
1201 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1202 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1203 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1205 if (driver_setup.no_sync ||
1206 (driver_setup.sync_mask &&
1207 (~driver_setup.sync_mask & (1 << target))))
1208 nv->bus[bus].target[target].parameter.enable_sync = 0;
1209 if (driver_setup.no_wide ||
1210 (driver_setup.wide_mask &&
1211 (~driver_setup.wide_mask & (1 << target))))
1212 nv->bus[bus].target[target].parameter.enable_wide = 0;
1213 if (IS_ISP1x160(ha)) {
1214 if (driver_setup.no_ppr ||
1215 (driver_setup.ppr_mask &&
1216 (~driver_setup.ppr_mask & (1 << target))))
1217 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1220 spin_lock_irqsave(ha->host->host_lock, flags);
1221 if (nv->bus[bus].target[target].parameter.enable_sync)
1222 status = qla1280_set_target_parameters(ha, bus, target);
1223 qla1280_get_target_parameters(ha, device);
1224 spin_unlock_irqrestore(ha->host->host_lock, flags);
1231 * Process completed commands.
1234 * ha = adapter block pointer.
1237 qla1280_done(struct scsi_qla_host *ha)
1240 struct list_head *done_q;
1242 struct scsi_cmnd *cmd;
1244 ENTER("qla1280_done");
1246 done_q = &ha->done_q;
1248 while (!list_empty(done_q)) {
1249 sp = list_entry(done_q->next, struct srb, list);
1251 list_del(&sp->list);
1254 bus = SCSI_BUS_32(cmd);
1255 target = SCSI_TCN_32(cmd);
1257 switch ((CMD_RESULT(cmd) >> 16)) {
1259 /* Issue marker command. */
1260 if (!ha->flags.abort_isp_active)
1261 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1264 sp->flags &= ~SRB_ABORT_PENDING;
1265 sp->flags |= SRB_ABORTED;
1271 /* Release memory used for this I/O */
1272 scsi_dma_unmap(cmd);
1274 /* Call the mid-level driver interrupt handler */
1277 if (sp->wait == NULL)
1282 LEAVE("qla1280_done");
1286 * Translates a ISP error to a Linux SCSI error
1289 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1291 int host_status = DID_ERROR;
1292 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1293 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1294 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1295 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1296 #if DEBUG_QLA1280_INTR
1297 static char *reason[] = {
1309 #endif /* DEBUG_QLA1280_INTR */
1311 ENTER("qla1280_return_status");
1313 #if DEBUG_QLA1280_INTR
1315 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1320 switch (comp_status) {
1322 host_status = DID_OK;
1326 if (!(state_flags & SF_GOT_BUS))
1327 host_status = DID_NO_CONNECT;
1328 else if (!(state_flags & SF_GOT_TARGET))
1329 host_status = DID_BAD_TARGET;
1330 else if (!(state_flags & SF_SENT_CDB))
1331 host_status = DID_ERROR;
1332 else if (!(state_flags & SF_TRANSFERRED_DATA))
1333 host_status = DID_ERROR;
1334 else if (!(state_flags & SF_GOT_STATUS))
1335 host_status = DID_ERROR;
1336 else if (!(state_flags & SF_GOT_SENSE))
1337 host_status = DID_ERROR;
1341 host_status = DID_RESET;
1345 host_status = DID_ABORT;
1349 host_status = DID_TIME_OUT;
1352 case CS_DATA_OVERRUN:
1353 dprintk(2, "Data overrun 0x%x\n", residual_length);
1354 dprintk(2, "qla1280_return_status: response packet data\n");
1355 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1356 host_status = DID_ERROR;
1359 case CS_DATA_UNDERRUN:
1360 if ((scsi_bufflen(cp) - residual_length) <
1363 "scsi: Underflow detected - retrying "
1365 host_status = DID_ERROR;
1367 scsi_set_resid(cp, residual_length);
1368 host_status = DID_OK;
1373 host_status = DID_ERROR;
1377 #if DEBUG_QLA1280_INTR
1378 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1379 reason[host_status], scsi_status);
1382 LEAVE("qla1280_return_status");
1384 return (scsi_status & 0xff) | (host_status << 16);
1387 /****************************************************************************/
1388 /* QLogic ISP1280 Hardware Support Functions. */
1389 /****************************************************************************/
1392 * qla1280_initialize_adapter
1396 * ha = adapter block pointer.
1402 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1404 struct device_reg __iomem *reg;
1407 unsigned long flags;
1409 ENTER("qla1280_initialize_adapter");
1411 /* Clear adapter flags. */
1412 ha->flags.online = 0;
1413 ha->flags.disable_host_adapter = 0;
1414 ha->flags.reset_active = 0;
1415 ha->flags.abort_isp_active = 0;
1417 /* TODO: implement support for the 1040 nvram format */
1419 driver_setup.no_nvram = 1;
1421 dprintk(1, "Configure PCI space for adapter...\n");
1425 /* Insure mailbox registers are free. */
1426 WRT_REG_WORD(®->semaphore, 0);
1427 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1428 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1429 RD_REG_WORD(®->host_cmd);
1431 if (qla1280_read_nvram(ha)) {
1432 dprintk(2, "qla1280_initialize_adapter: failed to read "
1437 * It's necessary to grab the spin here as qla1280_mailbox_command
1438 * needs to be able to drop the lock unconditionally to wait
1441 spin_lock_irqsave(ha->host->host_lock, flags);
1443 status = qla1280_load_firmware(ha);
1445 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1450 /* Setup adapter based on NVRAM parameters. */
1451 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1452 qla1280_nvram_config(ha);
1454 if (ha->flags.disable_host_adapter) {
1459 status = qla1280_init_rings(ha);
1463 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1464 for (bus = 0; bus < ha->ports; bus++) {
1465 if (!ha->bus_settings[bus].disable_scsi_reset &&
1466 qla1280_bus_reset(ha, bus) &&
1467 qla1280_bus_reset(ha, bus))
1468 ha->bus_settings[bus].scsi_bus_dead = 1;
1471 ha->flags.online = 1;
1473 spin_unlock_irqrestore(ha->host->host_lock, flags);
1476 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1478 LEAVE("qla1280_initialize_adapter");
1483 * qla1280_request_firmware
1484 * Acquire firmware for chip. Retain in memory
1485 * for error recovery.
1488 * ha = adapter block pointer.
1491 * Pointer to firmware image or an error code
1492 * cast to pointer via ERR_PTR().
1494 static const struct firmware *
1495 qla1280_request_firmware(struct scsi_qla_host *ha)
1497 const struct firmware *fw;
1502 spin_unlock_irq(ha->host->host_lock);
1503 mutex_lock(&qla1280_firmware_mutex);
1505 index = ql1280_board_tbl[ha->devnum].fw_index;
1506 fw = qla1280_fw_tbl[index].fw;
1510 fwname = qla1280_fw_tbl[index].fwname;
1511 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1514 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1519 if ((fw->size % 2) || (fw->size < 6)) {
1520 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1522 release_firmware(fw);
1523 fw = ERR_PTR(-EINVAL);
1527 qla1280_fw_tbl[index].fw = fw;
1530 ha->fwver1 = fw->data[0];
1531 ha->fwver2 = fw->data[1];
1532 ha->fwver3 = fw->data[2];
1534 mutex_unlock(&qla1280_firmware_mutex);
1535 spin_lock_irq(ha->host->host_lock);
1541 * Test chip for proper operation.
1544 * ha = adapter block pointer.
1550 qla1280_chip_diag(struct scsi_qla_host *ha)
1552 uint16_t mb[MAILBOX_REGISTER_COUNT];
1553 struct device_reg __iomem *reg = ha->iobase;
1557 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1559 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1561 /* Soft reset chip and wait for it to finish. */
1562 WRT_REG_WORD(®->ictrl, ISP_RESET);
1565 * We can't do a traditional PCI write flush here by reading
1566 * back the register. The card will not respond once the reset
1567 * is in action and we end up with a machine check exception
1568 * instead. Nothing to do but wait and hope for the best.
1569 * A portable pci_write_flush(pdev) call would be very useful here.
1572 data = qla1280_debounce_register(®->ictrl);
1574 * Yet another QLogic gem ;-(
1576 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1578 data = RD_REG_WORD(®->ictrl);
1584 /* Reset register cleared by chip reset. */
1585 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1587 WRT_REG_WORD(®->cfg_1, 0);
1589 /* Reset RISC and disable BIOS which
1590 allows RISC to execute out of RAM. */
1591 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1592 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1594 RD_REG_WORD(®->id_l); /* Flush PCI write */
1595 data = qla1280_debounce_register(®->mailbox0);
1598 * I *LOVE* this code!
1600 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1602 data = RD_REG_WORD(®->mailbox0);
1608 /* Check product ID of chip */
1609 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1611 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1612 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1613 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1614 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1615 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1616 printk(KERN_INFO "qla1280: Wrong product ID = "
1617 "0x%x,0x%x,0x%x,0x%x\n",
1618 RD_REG_WORD(®->mailbox1),
1619 RD_REG_WORD(®->mailbox2),
1620 RD_REG_WORD(®->mailbox3),
1621 RD_REG_WORD(®->mailbox4));
1626 * Enable ints early!!!
1628 qla1280_enable_intrs(ha);
1630 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1631 /* Wrap Incoming Mailboxes Test. */
1632 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1641 status = qla1280_mailbox_command(ha, 0xff, mb);
1645 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1646 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1648 printk(KERN_INFO "qla1280: Failed mbox check\n");
1652 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1655 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1660 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1662 /* enter with host_lock acquired */
1664 const struct firmware *fw;
1665 const __le16 *fw_data;
1666 uint16_t risc_address, risc_code_size;
1667 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1670 fw = qla1280_request_firmware(ha);
1674 fw_data = (const __le16 *)&fw->data[0];
1675 ha->fwstart = __le16_to_cpu(fw_data[2]);
1677 /* Load RISC code. */
1678 risc_address = ha->fwstart;
1679 fw_data = (const __le16 *)&fw->data[6];
1680 risc_code_size = (fw->size - 6) / 2;
1682 for (i = 0; i < risc_code_size; i++) {
1683 mb[0] = MBC_WRITE_RAM_WORD;
1684 mb[1] = risc_address + i;
1685 mb[2] = __le16_to_cpu(fw_data[i]);
1687 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1689 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1698 #ifdef QLA_64BIT_PTR
1699 #define LOAD_CMD MBC_LOAD_RAM_A64_ROM
1700 #define DUMP_CMD MBC_DUMP_RAM_A64_ROM
1701 #define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1703 #define LOAD_CMD MBC_LOAD_RAM
1704 #define DUMP_CMD MBC_DUMP_RAM
1705 #define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1708 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1710 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1712 /* enter with host_lock acquired */
1713 const struct firmware *fw;
1714 const __le16 *fw_data;
1715 uint16_t risc_address, risc_code_size;
1716 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1717 int err = 0, num, i;
1722 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1727 fw = qla1280_request_firmware(ha);
1731 fw_data = (const __le16 *)&fw->data[0];
1732 ha->fwstart = __le16_to_cpu(fw_data[2]);
1734 /* Load RISC code. */
1735 risc_address = ha->fwstart;
1736 fw_data = (const __le16 *)&fw->data[6];
1737 risc_code_size = (fw->size - 6) / 2;
1739 dprintk(1, "%s: DMA RISC code (%i) words\n",
1740 __func__, risc_code_size);
1743 while (risc_code_size > 0) {
1744 int warn __attribute__((unused)) = 0;
1748 if (cnt > risc_code_size)
1749 cnt = risc_code_size;
1751 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1753 fw_data, cnt, num, risc_address);
1754 for(i = 0; i < cnt; i++)
1755 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1758 mb[1] = risc_address;
1760 mb[3] = ha->request_dma & 0xffff;
1761 mb[2] = (ha->request_dma >> 16) & 0xffff;
1762 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1763 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1764 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1766 (void *)(long)ha->request_dma,
1767 mb[6], mb[7], mb[2], mb[3]);
1768 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1770 printk(KERN_ERR "scsi(%li): Failed to load partial "
1771 "segment of f\n", ha->host_no);
1777 mb[1] = risc_address;
1779 mb[3] = p_tbuf & 0xffff;
1780 mb[2] = (p_tbuf >> 16) & 0xffff;
1781 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1782 mb[6] = upper_32_bits(p_tbuf) >> 16;
1784 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1787 "Failed to dump partial segment of f/w\n");
1790 sp = (uint8_t *)ha->request_ring;
1791 for (i = 0; i < (cnt << 1); i++) {
1792 if (tbuf[i] != sp[i] && warn++ < 10) {
1793 printk(KERN_ERR "%s: FW compare error @ "
1794 "byte(0x%x) loop#=%x\n",
1796 printk(KERN_ERR "%s: FWbyte=%x "
1798 __func__, sp[i], tbuf[i]);
1803 risc_address += cnt;
1804 risc_code_size = risc_code_size - cnt;
1805 fw_data = fw_data + cnt;
1811 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1817 qla1280_start_firmware(struct scsi_qla_host *ha)
1819 uint16_t mb[MAILBOX_REGISTER_COUNT];
1822 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1825 /* Verify checksum of loaded RISC code. */
1826 mb[0] = MBC_VERIFY_CHECKSUM;
1827 /* mb[1] = ql12_risc_code_addr01; */
1828 mb[1] = ha->fwstart;
1829 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1831 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1835 /* Start firmware execution. */
1836 dprintk(1, "%s: start firmware running.\n", __func__);
1837 mb[0] = MBC_EXECUTE_FIRMWARE;
1838 mb[1] = ha->fwstart;
1839 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1841 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1849 qla1280_load_firmware(struct scsi_qla_host *ha)
1851 /* enter with host_lock taken */
1854 err = qla1280_chip_diag(ha);
1858 err = qla1280_load_firmware_pio(ha);
1860 err = qla1280_load_firmware_dma(ha);
1863 err = qla1280_start_firmware(ha);
1872 * ha = adapter block pointer.
1873 * ha->request_ring = request ring virtual address
1874 * ha->response_ring = response ring virtual address
1875 * ha->request_dma = request ring physical address
1876 * ha->response_dma = response ring physical address
1882 qla1280_init_rings(struct scsi_qla_host *ha)
1884 uint16_t mb[MAILBOX_REGISTER_COUNT];
1887 ENTER("qla1280_init_rings");
1889 /* Clear outstanding commands array. */
1890 memset(ha->outstanding_cmds, 0,
1891 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1893 /* Initialize request queue. */
1894 ha->request_ring_ptr = ha->request_ring;
1895 ha->req_ring_index = 0;
1896 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1897 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1898 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1899 mb[1] = REQUEST_ENTRY_CNT;
1900 mb[3] = ha->request_dma & 0xffff;
1901 mb[2] = (ha->request_dma >> 16) & 0xffff;
1903 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1904 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1905 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1906 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1908 /* Initialize response queue. */
1909 ha->response_ring_ptr = ha->response_ring;
1910 ha->rsp_ring_index = 0;
1911 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1912 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1913 mb[1] = RESPONSE_ENTRY_CNT;
1914 mb[3] = ha->response_dma & 0xffff;
1915 mb[2] = (ha->response_dma >> 16) & 0xffff;
1917 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1918 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1919 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1920 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1925 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1927 LEAVE("qla1280_init_rings");
1932 qla1280_print_settings(struct nvram *nv)
1934 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1935 nv->bus[0].config_1.initiator_id);
1936 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1937 nv->bus[1].config_1.initiator_id);
1939 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1940 nv->bus[0].bus_reset_delay);
1941 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1942 nv->bus[1].bus_reset_delay);
1944 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1945 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1946 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1947 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1949 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1950 nv->bus[0].config_2.async_data_setup_time);
1951 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1952 nv->bus[1].config_2.async_data_setup_time);
1954 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1955 nv->bus[0].config_2.req_ack_active_negation);
1956 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1957 nv->bus[1].config_2.req_ack_active_negation);
1959 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1960 nv->bus[0].config_2.data_line_active_negation);
1961 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1962 nv->bus[1].config_2.data_line_active_negation);
1964 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1965 nv->cntr_flags_1.disable_loading_risc_code);
1967 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1968 nv->cntr_flags_1.enable_64bit_addressing);
1970 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1971 nv->bus[0].selection_timeout);
1972 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1973 nv->bus[1].selection_timeout);
1975 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1976 nv->bus[0].max_queue_depth);
1977 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1978 nv->bus[1].max_queue_depth);
1982 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1984 struct nvram *nv = &ha->nvram;
1986 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
1987 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
1988 nv->bus[bus].target[target].parameter.tag_queuing = 1;
1989 nv->bus[bus].target[target].parameter.enable_sync = 1;
1990 #if 1 /* Some SCSI Processors do not seem to like this */
1991 nv->bus[bus].target[target].parameter.enable_wide = 1;
1993 nv->bus[bus].target[target].execution_throttle =
1994 nv->bus[bus].max_queue_depth - 1;
1995 nv->bus[bus].target[target].parameter.parity_checking = 1;
1996 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
1998 if (IS_ISP1x160(ha)) {
1999 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2000 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2001 nv->bus[bus].target[target].sync_period = 9;
2002 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2003 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2004 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2006 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2007 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2008 nv->bus[bus].target[target].sync_period = 10;
2013 qla1280_set_defaults(struct scsi_qla_host *ha)
2015 struct nvram *nv = &ha->nvram;
2018 dprintk(1, "Using defaults for NVRAM: \n");
2019 memset(nv, 0, sizeof(struct nvram));
2021 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2022 nv->firmware_feature.f.enable_fast_posting = 1;
2023 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2024 nv->termination.scsi_bus_0_control = 3;
2025 nv->termination.scsi_bus_1_control = 3;
2026 nv->termination.auto_term_support = 1;
2029 * Set default FIFO magic - What appropriate values would be here
2030 * is unknown. This is what I have found testing with 12160s.
2032 * Now, I would love the magic decoder ring for this one, the
2033 * header file provided by QLogic seems to be bogus or incomplete
2036 nv->isp_config.burst_enable = 1;
2038 nv->isp_config.fifo_threshold |= 3;
2040 nv->isp_config.fifo_threshold |= 4;
2042 if (IS_ISP1x160(ha))
2043 nv->isp_parameter = 0x01; /* fast memory enable */
2045 for (bus = 0; bus < MAX_BUSES; bus++) {
2046 nv->bus[bus].config_1.initiator_id = 7;
2047 nv->bus[bus].config_2.req_ack_active_negation = 1;
2048 nv->bus[bus].config_2.data_line_active_negation = 1;
2049 nv->bus[bus].selection_timeout = 250;
2050 nv->bus[bus].max_queue_depth = 32;
2052 if (IS_ISP1040(ha)) {
2053 nv->bus[bus].bus_reset_delay = 3;
2054 nv->bus[bus].config_2.async_data_setup_time = 6;
2055 nv->bus[bus].retry_delay = 1;
2057 nv->bus[bus].bus_reset_delay = 5;
2058 nv->bus[bus].config_2.async_data_setup_time = 8;
2061 for (target = 0; target < MAX_TARGETS; target++)
2062 qla1280_set_target_defaults(ha, bus, target);
2067 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2069 struct nvram *nv = &ha->nvram;
2070 uint16_t mb[MAILBOX_REGISTER_COUNT];
2074 /* Set Target Parameters. */
2075 mb[0] = MBC_SET_TARGET_PARAMETERS;
2076 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2079 * Do not enable sync and ppr for the initial INQUIRY run. We
2080 * enable this later if we determine the target actually
2083 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2084 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2086 if (IS_ISP1x160(ha))
2087 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2089 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2090 mb[3] |= nv->bus[bus].target[target].sync_period;
2091 status = qla1280_mailbox_command(ha, 0x0f, mb);
2093 /* Save Tag queuing enable flag. */
2094 flag = (BIT_0 << target);
2095 if (nv->bus[bus].target[target].parameter.tag_queuing)
2096 ha->bus_settings[bus].qtag_enables |= flag;
2098 /* Save Device enable flag. */
2099 if (IS_ISP1x160(ha)) {
2100 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2101 ha->bus_settings[bus].device_enables |= flag;
2102 ha->bus_settings[bus].lun_disables |= 0;
2104 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2105 ha->bus_settings[bus].device_enables |= flag;
2106 /* Save LUN disable flag. */
2107 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2108 ha->bus_settings[bus].lun_disables |= flag;
2111 /* Set Device Queue Parameters. */
2112 for (lun = 0; lun < MAX_LUNS; lun++) {
2113 mb[0] = MBC_SET_DEVICE_QUEUE;
2114 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2116 mb[2] = nv->bus[bus].max_queue_depth;
2117 mb[3] = nv->bus[bus].target[target].execution_throttle;
2118 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2125 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2127 struct nvram *nv = &ha->nvram;
2128 uint16_t mb[MAILBOX_REGISTER_COUNT];
2131 /* SCSI Reset Disable. */
2132 ha->bus_settings[bus].disable_scsi_reset =
2133 nv->bus[bus].config_1.scsi_reset_disable;
2136 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2137 mb[0] = MBC_SET_INITIATOR_ID;
2138 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2139 ha->bus_settings[bus].id;
2140 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2143 ha->bus_settings[bus].bus_reset_delay =
2144 nv->bus[bus].bus_reset_delay;
2146 /* Command queue depth per device. */
2147 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2149 /* Set target parameters. */
2150 for (target = 0; target < MAX_TARGETS; target++)
2151 status |= qla1280_config_target(ha, bus, target);
2157 qla1280_nvram_config(struct scsi_qla_host *ha)
2159 struct device_reg __iomem *reg = ha->iobase;
2160 struct nvram *nv = &ha->nvram;
2161 int bus, target, status = 0;
2162 uint16_t mb[MAILBOX_REGISTER_COUNT];
2164 ENTER("qla1280_nvram_config");
2166 if (ha->nvram_valid) {
2167 /* Always force AUTO sense for LINUX SCSI */
2168 for (bus = 0; bus < MAX_BUSES; bus++)
2169 for (target = 0; target < MAX_TARGETS; target++) {
2170 nv->bus[bus].target[target].parameter.
2171 auto_request_sense = 1;
2174 qla1280_set_defaults(ha);
2177 qla1280_print_settings(nv);
2179 /* Disable RISC load of firmware. */
2180 ha->flags.disable_risc_code_load =
2181 nv->cntr_flags_1.disable_loading_risc_code;
2183 if (IS_ISP1040(ha)) {
2184 uint16_t hwrev, cfg1, cdma_conf;
2186 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2188 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2189 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2191 /* Busted fifo, says mjacob. */
2192 if (hwrev != ISP_CFG0_1040A)
2193 cfg1 |= nv->isp_config.fifo_threshold << 4;
2195 cfg1 |= nv->isp_config.burst_enable << 2;
2196 WRT_REG_WORD(®->cfg_1, cfg1);
2198 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2199 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2201 uint16_t cfg1, term;
2203 /* Set ISP hardware DMA burst */
2204 cfg1 = nv->isp_config.fifo_threshold << 4;
2205 cfg1 |= nv->isp_config.burst_enable << 2;
2206 /* Enable DMA arbitration on dual channel controllers */
2209 WRT_REG_WORD(®->cfg_1, cfg1);
2211 /* Set SCSI termination. */
2212 WRT_REG_WORD(®->gpio_enable,
2213 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2214 term = nv->termination.scsi_bus_1_control;
2215 term |= nv->termination.scsi_bus_0_control << 2;
2216 term |= nv->termination.auto_term_support << 7;
2217 RD_REG_WORD(®->id_l); /* Flush PCI write */
2218 WRT_REG_WORD(®->gpio_data, term);
2220 RD_REG_WORD(®->id_l); /* Flush PCI write */
2222 /* ISP parameter word. */
2223 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2224 mb[1] = nv->isp_parameter;
2225 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2227 if (IS_ISP1x40(ha)) {
2228 /* clock rate - for qla1240 and older, only */
2229 mb[0] = MBC_SET_CLOCK_RATE;
2231 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2234 /* Firmware feature word. */
2235 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2236 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2237 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2238 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2239 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2241 /* Retry count and delay. */
2242 mb[0] = MBC_SET_RETRY_COUNT;
2243 mb[1] = nv->bus[0].retry_count;
2244 mb[2] = nv->bus[0].retry_delay;
2245 mb[6] = nv->bus[1].retry_count;
2246 mb[7] = nv->bus[1].retry_delay;
2247 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2248 BIT_1 | BIT_0, &mb[0]);
2250 /* ASYNC data setup time. */
2251 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2252 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2253 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2254 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2256 /* Active negation states. */
2257 mb[0] = MBC_SET_ACTIVE_NEGATION;
2259 if (nv->bus[0].config_2.req_ack_active_negation)
2261 if (nv->bus[0].config_2.data_line_active_negation)
2264 if (nv->bus[1].config_2.req_ack_active_negation)
2266 if (nv->bus[1].config_2.data_line_active_negation)
2268 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2270 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2271 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2272 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2275 mb[0] = MBC_SET_PCI_CONTROL;
2276 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2277 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2278 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2280 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2282 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2284 /* Selection timeout. */
2285 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2286 mb[1] = nv->bus[0].selection_timeout;
2287 mb[2] = nv->bus[1].selection_timeout;
2288 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2290 for (bus = 0; bus < ha->ports; bus++)
2291 status |= qla1280_config_bus(ha, bus);
2294 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2296 LEAVE("qla1280_nvram_config");
2301 * Get NVRAM data word
2302 * Calculates word position in NVRAM and calls request routine to
2303 * get the word from NVRAM.
2306 * ha = adapter block pointer.
2307 * address = NVRAM word address.
2313 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2318 nv_cmd = address << 16;
2319 nv_cmd |= NV_READ_OP;
2321 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2323 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2331 * Sends read command to NVRAM and gets data from NVRAM.
2334 * ha = adapter block pointer.
2335 * nv_cmd = Bit 26 = start bit
2336 * Bit 25, 24 = opcode
2337 * Bit 23-16 = address
2338 * Bit 15-0 = write data
2344 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2346 struct device_reg __iomem *reg = ha->iobase;
2351 /* Send command to NVRAM. */
2354 for (cnt = 0; cnt < 11; cnt++) {
2355 if (nv_cmd & BIT_31)
2356 qla1280_nv_write(ha, NV_DATA_OUT);
2358 qla1280_nv_write(ha, 0);
2362 /* Read data from NVRAM. */
2364 for (cnt = 0; cnt < 16; cnt++) {
2365 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2366 RD_REG_WORD(®->id_l); /* Flush PCI write */
2369 reg_data = RD_REG_WORD(®->nvram);
2370 if (reg_data & NV_DATA_IN)
2372 WRT_REG_WORD(®->nvram, NV_SELECT);
2373 RD_REG_WORD(®->id_l); /* Flush PCI write */
2377 /* Deselect chip. */
2379 WRT_REG_WORD(®->nvram, NV_DESELECT);
2380 RD_REG_WORD(®->id_l); /* Flush PCI write */
2387 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2389 struct device_reg __iomem *reg = ha->iobase;
2391 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2392 RD_REG_WORD(®->id_l); /* Flush PCI write */
2394 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2395 RD_REG_WORD(®->id_l); /* Flush PCI write */
2397 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2398 RD_REG_WORD(®->id_l); /* Flush PCI write */
2404 * Issue mailbox command and waits for completion.
2407 * ha = adapter block pointer.
2408 * mr = mailbox registers to load.
2409 * mb = data pointer for mailbox registers.
2412 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2418 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2420 struct device_reg __iomem *reg = ha->iobase;
2423 uint16_t *optr, *iptr;
2424 uint16_t __iomem *mptr;
2425 DECLARE_COMPLETION_ONSTACK(wait);
2427 ENTER("qla1280_mailbox_command");
2429 if (ha->mailbox_wait) {
2430 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2432 ha->mailbox_wait = &wait;
2435 * We really should start out by verifying that the mailbox is
2436 * available before starting sending the command data
2438 /* Load mailbox registers. */
2439 mptr = (uint16_t __iomem *) ®->mailbox0;
2441 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2443 WRT_REG_WORD(mptr, (*iptr));
2451 /* Issue set host interrupt command. */
2453 /* set up a timer just in case we're really jammed */
2454 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2455 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
2457 spin_unlock_irq(ha->host->host_lock);
2458 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2459 qla1280_debounce_register(®->istatus);
2461 wait_for_completion(&wait);
2462 del_timer_sync(&ha->mailbox_timer);
2464 spin_lock_irq(ha->host->host_lock);
2466 ha->mailbox_wait = NULL;
2468 /* Check for mailbox command timeout. */
2469 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2470 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2471 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2473 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2474 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2475 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2476 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2477 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2478 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2479 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2483 /* Load return mailbox registers. */
2485 iptr = (uint16_t *) &ha->mailbox_out[0];
2486 mr = MAILBOX_REGISTER_COUNT;
2487 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2489 if (ha->flags.reset_marker)
2490 qla1280_rst_aen(ha);
2493 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2494 "0x%x ****\n", mb[0]);
2496 LEAVE("qla1280_mailbox_command");
2502 * Polls ISP for interrupts.
2505 * ha = adapter block pointer.
2508 qla1280_poll(struct scsi_qla_host *ha)
2510 struct device_reg __iomem *reg = ha->iobase;
2514 /* ENTER("qla1280_poll"); */
2516 /* Check for pending interrupts. */
2517 data = RD_REG_WORD(®->istatus);
2518 if (data & RISC_INT)
2519 qla1280_isr(ha, &done_q);
2521 if (!ha->mailbox_wait) {
2522 if (ha->flags.reset_marker)
2523 qla1280_rst_aen(ha);
2526 if (!list_empty(&done_q))
2529 /* LEAVE("qla1280_poll"); */
2534 * Issue SCSI bus reset.
2537 * ha = adapter block pointer.
2538 * bus = SCSI bus number.
2544 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2546 uint16_t mb[MAILBOX_REGISTER_COUNT];
2547 uint16_t reset_delay;
2550 dprintk(3, "qla1280_bus_reset: entered\n");
2552 if (qla1280_verbose)
2553 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2556 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2557 mb[0] = MBC_BUS_RESET;
2558 mb[1] = reset_delay;
2559 mb[2] = (uint16_t) bus;
2560 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2563 if (ha->bus_settings[bus].failed_reset_count > 2)
2564 ha->bus_settings[bus].scsi_bus_dead = 1;
2565 ha->bus_settings[bus].failed_reset_count++;
2567 spin_unlock_irq(ha->host->host_lock);
2568 ssleep(reset_delay);
2569 spin_lock_irq(ha->host->host_lock);
2571 ha->bus_settings[bus].scsi_bus_dead = 0;
2572 ha->bus_settings[bus].failed_reset_count = 0;
2573 ha->bus_settings[bus].reset_marker = 0;
2574 /* Issue marker command. */
2575 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2579 * We should probably call qla1280_set_target_parameters()
2580 * here as well for all devices on the bus.
2584 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2586 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2592 * qla1280_device_reset
2593 * Issue bus device reset message to the target.
2596 * ha = adapter block pointer.
2597 * bus = SCSI BUS number.
2604 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2606 uint16_t mb[MAILBOX_REGISTER_COUNT];
2609 ENTER("qla1280_device_reset");
2611 mb[0] = MBC_ABORT_TARGET;
2612 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2614 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2616 /* Issue marker command. */
2617 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2620 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2622 LEAVE("qla1280_device_reset");
2627 * qla1280_abort_command
2628 * Abort command aborts a specified IOCB.
2631 * ha = adapter block pointer.
2632 * sp = SB structure pointer.
2638 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2640 uint16_t mb[MAILBOX_REGISTER_COUNT];
2641 unsigned int bus, target, lun;
2644 ENTER("qla1280_abort_command");
2646 bus = SCSI_BUS_32(sp->cmd);
2647 target = SCSI_TCN_32(sp->cmd);
2648 lun = SCSI_LUN_32(sp->cmd);
2650 sp->flags |= SRB_ABORT_PENDING;
2652 mb[0] = MBC_ABORT_COMMAND;
2653 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2654 mb[2] = handle >> 16;
2655 mb[3] = handle & 0xffff;
2656 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2659 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2660 sp->flags &= ~SRB_ABORT_PENDING;
2664 LEAVE("qla1280_abort_command");
2669 * qla1280_reset_adapter
2673 * ha = adapter block pointer.
2676 qla1280_reset_adapter(struct scsi_qla_host *ha)
2678 struct device_reg __iomem *reg = ha->iobase;
2680 ENTER("qla1280_reset_adapter");
2682 /* Disable ISP chip */
2683 ha->flags.online = 0;
2684 WRT_REG_WORD(®->ictrl, ISP_RESET);
2685 WRT_REG_WORD(®->host_cmd,
2686 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2687 RD_REG_WORD(®->id_l); /* Flush PCI write */
2689 LEAVE("qla1280_reset_adapter");
2693 * Issue marker command.
2694 * Function issues marker IOCB.
2697 * ha = adapter block pointer.
2698 * bus = SCSI BUS number
2701 * type = marker modifier
2704 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2706 struct mrk_entry *pkt;
2708 ENTER("qla1280_marker");
2710 /* Get request packet. */
2711 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2712 pkt->entry_type = MARKER_TYPE;
2713 pkt->lun = (uint8_t) lun;
2714 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2715 pkt->modifier = type;
2716 pkt->entry_status = 0;
2718 /* Issue command to ISP */
2719 qla1280_isp_cmd(ha);
2722 LEAVE("qla1280_marker");
2727 * qla1280_64bit_start_scsi
2728 * The start SCSI is responsible for building request packets on
2729 * request ring and modifying ISP input pointer.
2732 * ha = adapter block pointer.
2733 * sp = SB structure pointer.
2736 * 0 = success, was able to issue command.
2738 #ifdef QLA_64BIT_PTR
2740 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2742 struct device_reg __iomem *reg = ha->iobase;
2743 struct scsi_cmnd *cmd = sp->cmd;
2744 cmd_a64_entry_t *pkt;
2746 dma_addr_t dma_handle;
2753 ENTER("qla1280_64bit_start_scsi:");
2755 /* Calculate number of entries and segments required. */
2757 seg_cnt = scsi_dma_map(cmd);
2760 req_cnt += (seg_cnt - 2) / 5;
2761 if ((seg_cnt - 2) % 5)
2764 } else if (seg_cnt < 0) {
2769 if ((req_cnt + 2) >= ha->req_q_cnt) {
2770 /* Calculate number of free request entries. */
2771 cnt = RD_REG_WORD(®->mailbox4);
2772 if (ha->req_ring_index < cnt)
2773 ha->req_q_cnt = cnt - ha->req_ring_index;
2776 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2779 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2780 ha->req_q_cnt, seg_cnt);
2782 /* If room for request in request ring. */
2783 if ((req_cnt + 2) >= ha->req_q_cnt) {
2784 status = SCSI_MLQUEUE_HOST_BUSY;
2785 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
2786 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2791 /* Check for room in outstanding command list. */
2792 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2793 ha->outstanding_cmds[cnt] != NULL; cnt++);
2795 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2796 status = SCSI_MLQUEUE_HOST_BUSY;
2797 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2798 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2802 ha->outstanding_cmds[cnt] = sp;
2803 ha->req_q_cnt -= req_cnt;
2804 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2806 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2807 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2808 dprintk(2, " bus %i, target %i, lun %i\n",
2809 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2810 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2813 * Build command packet.
2815 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2817 pkt->entry_type = COMMAND_A64_TYPE;
2818 pkt->entry_count = (uint8_t) req_cnt;
2819 pkt->sys_define = (uint8_t) ha->req_ring_index;
2820 pkt->entry_status = 0;
2821 pkt->handle = cpu_to_le32(cnt);
2823 /* Zero out remaining portion of packet. */
2824 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2826 /* Set ISP command timeout. */
2827 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
2829 /* Set device target ID and LUN */
2830 pkt->lun = SCSI_LUN_32(cmd);
2831 pkt->target = SCSI_BUS_32(cmd) ?
2832 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2834 /* Enable simple tag queuing if device supports it. */
2835 if (cmd->device->simple_tags)
2836 pkt->control_flags |= cpu_to_le16(BIT_3);
2838 /* Load SCSI command packet. */
2839 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2840 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
2841 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2843 /* Set transfer direction. */
2844 dir = qla1280_data_direction(cmd);
2845 pkt->control_flags |= cpu_to_le16(dir);
2847 /* Set total data segment count. */
2848 pkt->dseg_count = cpu_to_le16(seg_cnt);
2851 * Load data segments.
2853 if (seg_cnt) { /* If data transfer. */
2854 struct scatterlist *sg, *s;
2855 int remseg = seg_cnt;
2857 sg = scsi_sglist(cmd);
2859 /* Setup packet address segment pointer. */
2860 dword_ptr = (u32 *)&pkt->dseg_0_address;
2862 /* Load command entry data segments. */
2863 for_each_sg(sg, s, seg_cnt, cnt) {
2867 dma_handle = sg_dma_address(s);
2869 cpu_to_le32(lower_32_bits(dma_handle));
2871 cpu_to_le32(upper_32_bits(dma_handle));
2872 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2873 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2874 cpu_to_le32(upper_32_bits(dma_handle)),
2875 cpu_to_le32(lower_32_bits(dma_handle)),
2876 cpu_to_le32(sg_dma_len(sg_next(s))));
2879 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2880 "command packet data - b %i, t %i, l %i \n",
2881 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2883 qla1280_dump_buffer(5, (char *)pkt,
2884 REQUEST_ENTRY_SIZE);
2887 * Build continuation packets.
2889 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2890 "remains\n", seg_cnt);
2892 while (remseg > 0) {
2893 /* Update sg start */
2895 /* Adjust ring index. */
2896 ha->req_ring_index++;
2897 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2898 ha->req_ring_index = 0;
2899 ha->request_ring_ptr =
2902 ha->request_ring_ptr++;
2904 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2906 /* Zero out packet. */
2907 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2909 /* Load packet defaults. */
2910 ((struct cont_a64_entry *) pkt)->entry_type =
2912 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2913 ((struct cont_a64_entry *) pkt)->sys_define =
2914 (uint8_t)ha->req_ring_index;
2915 /* Setup packet address segment pointer. */
2917 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2919 /* Load continuation entry data segments. */
2920 for_each_sg(sg, s, remseg, cnt) {
2923 dma_handle = sg_dma_address(s);
2925 cpu_to_le32(lower_32_bits(dma_handle));
2927 cpu_to_le32(upper_32_bits(dma_handle));
2929 cpu_to_le32(sg_dma_len(s));
2930 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2931 cpu_to_le32(upper_32_bits(dma_handle)),
2932 cpu_to_le32(lower_32_bits(dma_handle)),
2933 cpu_to_le32(sg_dma_len(s)));
2936 dprintk(5, "qla1280_64bit_start_scsi: "
2937 "continuation packet data - b %i, t "
2938 "%i, l %i \n", SCSI_BUS_32(cmd),
2939 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2940 qla1280_dump_buffer(5, (char *)pkt,
2941 REQUEST_ENTRY_SIZE);
2943 } else { /* No data transfer */
2944 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2945 "packet data - b %i, t %i, l %i \n",
2946 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2947 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2949 /* Adjust ring index. */
2950 ha->req_ring_index++;
2951 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2952 ha->req_ring_index = 0;
2953 ha->request_ring_ptr = ha->request_ring;
2955 ha->request_ring_ptr++;
2957 /* Set chip new ring index. */
2959 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
2960 sp->flags |= SRB_SENT;
2962 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
2966 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
2968 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
2972 #else /* !QLA_64BIT_PTR */
2975 * qla1280_32bit_start_scsi
2976 * The start SCSI is responsible for building request packets on
2977 * request ring and modifying ISP input pointer.
2979 * The Qlogic firmware interface allows every queue slot to have a SCSI
2980 * command and up to 4 scatter/gather (SG) entries. If we need more
2981 * than 4 SG entries, then continuation entries are used that can
2982 * hold another 7 entries each. The start routine determines if there
2983 * is eought empty slots then build the combination of requests to
2984 * fulfill the OS request.
2987 * ha = adapter block pointer.
2988 * sp = SCSI Request Block structure pointer.
2991 * 0 = success, was able to issue command.
2994 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2996 struct device_reg __iomem *reg = ha->iobase;
2997 struct scsi_cmnd *cmd = sp->cmd;
2998 struct cmd_entry *pkt;
3006 ENTER("qla1280_32bit_start_scsi");
3008 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3011 /* Calculate number of entries and segments required. */
3013 seg_cnt = scsi_dma_map(cmd);
3016 * if greater than four sg entries then we need to allocate
3017 * continuation entries
3020 req_cnt += (seg_cnt - 4) / 7;
3021 if ((seg_cnt - 4) % 7)
3024 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3025 cmd, seg_cnt, req_cnt);
3026 } else if (seg_cnt < 0) {
3031 if ((req_cnt + 2) >= ha->req_q_cnt) {
3032 /* Calculate number of free request entries. */
3033 cnt = RD_REG_WORD(®->mailbox4);
3034 if (ha->req_ring_index < cnt)
3035 ha->req_q_cnt = cnt - ha->req_ring_index;
3038 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3041 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3042 ha->req_q_cnt, seg_cnt);
3043 /* If room for request in request ring. */
3044 if ((req_cnt + 2) >= ha->req_q_cnt) {
3045 status = SCSI_MLQUEUE_HOST_BUSY;
3046 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3047 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3048 ha->req_q_cnt, req_cnt);
3052 /* Check for empty slot in outstanding command list. */
3053 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3054 ha->outstanding_cmds[cnt]; cnt++);
3056 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3057 status = SCSI_MLQUEUE_HOST_BUSY;
3058 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3059 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3063 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3064 ha->outstanding_cmds[cnt] = sp;
3065 ha->req_q_cnt -= req_cnt;
3068 * Build command packet.
3070 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3072 pkt->entry_type = COMMAND_TYPE;
3073 pkt->entry_count = (uint8_t) req_cnt;
3074 pkt->sys_define = (uint8_t) ha->req_ring_index;
3075 pkt->entry_status = 0;
3076 pkt->handle = cpu_to_le32(cnt);
3078 /* Zero out remaining portion of packet. */
3079 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3081 /* Set ISP command timeout. */
3082 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
3084 /* Set device target ID and LUN */
3085 pkt->lun = SCSI_LUN_32(cmd);
3086 pkt->target = SCSI_BUS_32(cmd) ?
3087 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3089 /* Enable simple tag queuing if device supports it. */
3090 if (cmd->device->simple_tags)
3091 pkt->control_flags |= cpu_to_le16(BIT_3);
3093 /* Load SCSI command packet. */
3094 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3095 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
3097 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3098 /* Set transfer direction. */
3099 dir = qla1280_data_direction(cmd);
3100 pkt->control_flags |= cpu_to_le16(dir);
3102 /* Set total data segment count. */
3103 pkt->dseg_count = cpu_to_le16(seg_cnt);
3106 * Load data segments.
3109 struct scatterlist *sg, *s;
3110 int remseg = seg_cnt;
3112 sg = scsi_sglist(cmd);
3114 /* Setup packet address segment pointer. */
3115 dword_ptr = &pkt->dseg_0_address;
3117 dprintk(3, "Building S/G data segments..\n");
3118 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3120 /* Load command entry data segments. */
3121 for_each_sg(sg, s, seg_cnt, cnt) {
3125 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3126 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3127 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3128 (lower_32_bits(sg_dma_address(s))),
3133 * Build continuation packets.
3135 dprintk(3, "S/G Building Continuation"
3136 "...seg_cnt=0x%x remains\n", seg_cnt);
3137 while (remseg > 0) {
3138 /* Continue from end point */
3140 /* Adjust ring index. */
3141 ha->req_ring_index++;
3142 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3143 ha->req_ring_index = 0;
3144 ha->request_ring_ptr =
3147 ha->request_ring_ptr++;
3149 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3151 /* Zero out packet. */
3152 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3154 /* Load packet defaults. */
3155 ((struct cont_entry *) pkt)->
3156 entry_type = CONTINUE_TYPE;
3157 ((struct cont_entry *) pkt)->entry_count = 1;
3159 ((struct cont_entry *) pkt)->sys_define =
3160 (uint8_t) ha->req_ring_index;
3162 /* Setup packet address segment pointer. */
3164 &((struct cont_entry *) pkt)->dseg_0_address;
3166 /* Load continuation entry data segments. */
3167 for_each_sg(sg, s, remseg, cnt) {
3171 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3173 cpu_to_le32(sg_dma_len(s));
3175 "S/G Segment Cont. phys_addr=0x%x, "
3177 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
3178 cpu_to_le32(sg_dma_len(s)));
3181 dprintk(5, "qla1280_32bit_start_scsi: "
3182 "continuation packet data - "
3183 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3184 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3185 qla1280_dump_buffer(5, (char *)pkt,
3186 REQUEST_ENTRY_SIZE);
3188 } else { /* No data transfer at all */
3189 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3190 "packet data - \n");
3191 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3193 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3194 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3195 REQUEST_ENTRY_SIZE);
3197 /* Adjust ring index. */
3198 ha->req_ring_index++;
3199 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3200 ha->req_ring_index = 0;
3201 ha->request_ring_ptr = ha->request_ring;
3203 ha->request_ring_ptr++;
3205 /* Set chip new ring index. */
3206 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3207 "for pending command\n");
3208 sp->flags |= SRB_SENT;
3210 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3214 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3216 LEAVE("qla1280_32bit_start_scsi");
3224 * Function is responsible for locking ring and
3225 * getting a zeroed out request packet.
3228 * ha = adapter block pointer.
3231 * 0 = failed to get slot.
3234 qla1280_req_pkt(struct scsi_qla_host *ha)
3236 struct device_reg __iomem *reg = ha->iobase;
3237 request_t *pkt = NULL;
3241 ENTER("qla1280_req_pkt");
3244 * This can be called from interrupt context, damn it!!!
3246 /* Wait for 30 seconds for slot. */
3247 for (timer = 15000000; timer; timer--) {
3248 if (ha->req_q_cnt > 0) {
3249 /* Calculate number of free request entries. */
3250 cnt = RD_REG_WORD(®->mailbox4);
3251 if (ha->req_ring_index < cnt)
3252 ha->req_q_cnt = cnt - ha->req_ring_index;
3255 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3258 /* Found empty request ring slot? */
3259 if (ha->req_q_cnt > 0) {
3261 pkt = ha->request_ring_ptr;
3263 /* Zero out packet. */
3264 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3267 * How can this be right when we have a ring
3270 /* Set system defined field. */
3271 pkt->sys_define = (uint8_t) ha->req_ring_index;
3273 /* Set entry count. */
3274 pkt->entry_count = 1;
3281 /* Check for pending interrupts. */
3286 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3288 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3295 * Function is responsible for modifying ISP input pointer.
3296 * Releases ring lock.
3299 * ha = adapter block pointer.
3302 qla1280_isp_cmd(struct scsi_qla_host *ha)
3304 struct device_reg __iomem *reg = ha->iobase;
3306 ENTER("qla1280_isp_cmd");
3308 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3309 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3310 REQUEST_ENTRY_SIZE);
3312 /* Adjust ring index. */
3313 ha->req_ring_index++;
3314 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3315 ha->req_ring_index = 0;
3316 ha->request_ring_ptr = ha->request_ring;
3318 ha->request_ring_ptr++;
3321 * Update request index to mailbox4 (Request Queue In).
3323 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3325 LEAVE("qla1280_isp_cmd");
3328 /****************************************************************************/
3329 /* Interrupt Service Routine. */
3330 /****************************************************************************/
3332 /****************************************************************************
3334 * Calls I/O done on command completion.
3337 * ha = adapter block pointer.
3338 * done_q = done queue.
3339 ****************************************************************************/
3341 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3343 struct device_reg __iomem *reg = ha->iobase;
3344 struct response *pkt;
3345 struct srb *sp = NULL;
3346 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3351 ENTER("qla1280_isr");
3353 istatus = RD_REG_WORD(®->istatus);
3354 if (!(istatus & (RISC_INT | PCI_INT)))
3357 /* Save mailbox register 5 */
3358 mailbox[5] = RD_REG_WORD(®->mailbox5);
3360 /* Check for mailbox interrupt. */
3362 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3364 if (mailbox[0] & BIT_0) {
3365 /* Get mailbox data. */
3366 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3369 *wptr++ = RD_REG_WORD(®->mailbox0);
3370 *wptr++ = RD_REG_WORD(®->mailbox1);
3371 *wptr = RD_REG_WORD(®->mailbox2);
3372 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3374 *wptr++ = RD_REG_WORD(®->mailbox3);
3375 *wptr++ = RD_REG_WORD(®->mailbox4);
3377 *wptr++ = RD_REG_WORD(®->mailbox6);
3378 *wptr = RD_REG_WORD(®->mailbox7);
3381 /* Release mailbox registers. */
3383 WRT_REG_WORD(®->semaphore, 0);
3384 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3386 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3389 /* Handle asynchronous event */
3390 switch (mailbox[0]) {
3391 case MBA_SCSI_COMPLETION: /* Response completion */
3392 dprintk(5, "qla1280_isr: mailbox SCSI response "
3395 if (ha->flags.online) {
3396 /* Get outstanding command index. */
3397 index = mailbox[2] << 16 | mailbox[1];
3399 /* Validate handle. */
3400 if (index < MAX_OUTSTANDING_COMMANDS)
3401 sp = ha->outstanding_cmds[index];
3406 /* Free outstanding command slot. */
3407 ha->outstanding_cmds[index] = NULL;
3409 /* Save ISP completion status */
3410 CMD_RESULT(sp->cmd) = 0;
3411 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3413 /* Place block on done queue */
3414 list_add_tail(&sp->list, done_q);
3417 * If we get here we have a real problem!
3420 "qla1280: ISP invalid handle\n");
3425 case MBA_BUS_RESET: /* SCSI Bus Reset */
3426 ha->flags.reset_marker = 1;
3427 index = mailbox[6] & BIT_0;
3428 ha->bus_settings[index].reset_marker = 1;
3430 printk(KERN_DEBUG "qla1280_isr(): index %i "
3431 "asynchronous BUS_RESET\n", index);
3434 case MBA_SYSTEM_ERR: /* System Error */
3436 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3437 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3441 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3443 "qla1280: ISP Request Transfer Error\n");
3446 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3448 "qla1280: ISP Response Transfer Error\n");
3451 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3452 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3455 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3457 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3460 case MBA_DEVICE_RESET: /* Bus Device Reset */
3461 printk(KERN_INFO "qla1280_isr(): asynchronous "
3462 "BUS_DEVICE_RESET\n");
3464 ha->flags.reset_marker = 1;
3465 index = mailbox[6] & BIT_0;
3466 ha->bus_settings[index].reset_marker = 1;
3469 case MBA_BUS_MODE_CHANGE:
3471 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3475 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3476 if (mailbox[0] < MBA_ASYNC_EVENT) {
3478 memcpy((uint16_t *) ha->mailbox_out, wptr,
3479 MAILBOX_REGISTER_COUNT *
3482 if(ha->mailbox_wait != NULL)
3483 complete(ha->mailbox_wait);
3488 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3492 * We will receive interrupts during mailbox testing prior to
3493 * the card being marked online, hence the double check.
3495 if (!(ha->flags.online && !ha->mailbox_wait)) {
3496 dprintk(2, "qla1280_isr: Response pointer Error\n");
3500 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3503 while (ha->rsp_ring_index != mailbox[5]) {
3504 pkt = ha->response_ring_ptr;
3506 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3507 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3508 dprintk(5,"qla1280_isr: response packet data\n");
3509 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3511 if (pkt->entry_type == STATUS_TYPE) {
3512 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3513 || pkt->comp_status || pkt->entry_status) {
3514 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3515 "0x%x mailbox[5] = 0x%x, comp_status "
3516 "= 0x%x, scsi_status = 0x%x\n",
3517 ha->rsp_ring_index, mailbox[5],
3518 le16_to_cpu(pkt->comp_status),
3519 le16_to_cpu(pkt->scsi_status));
3522 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3523 "0x%x, mailbox[5] = 0x%x\n",
3524 ha->rsp_ring_index, mailbox[5]);
3525 dprintk(2, "qla1280_isr: response packet data\n");
3526 qla1280_dump_buffer(2, (char *)pkt,
3527 RESPONSE_ENTRY_SIZE);
3530 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3531 dprintk(2, "status: Cmd %p, handle %i\n",
3532 ha->outstanding_cmds[pkt->handle]->cmd,
3534 if (pkt->entry_type == STATUS_TYPE)
3535 qla1280_status_entry(ha, pkt, done_q);
3537 qla1280_error_entry(ha, pkt, done_q);
3538 /* Adjust ring index. */
3539 ha->rsp_ring_index++;
3540 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3541 ha->rsp_ring_index = 0;
3542 ha->response_ring_ptr = ha->response_ring;
3544 ha->response_ring_ptr++;
3545 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3550 LEAVE("qla1280_isr");
3555 * Processes asynchronous reset.
3558 * ha = adapter block pointer.
3561 qla1280_rst_aen(struct scsi_qla_host *ha)
3565 ENTER("qla1280_rst_aen");
3567 if (ha->flags.online && !ha->flags.reset_active &&
3568 !ha->flags.abort_isp_active) {
3569 ha->flags.reset_active = 1;
3570 while (ha->flags.reset_marker) {
3571 /* Issue marker command. */
3572 ha->flags.reset_marker = 0;
3573 for (bus = 0; bus < ha->ports &&
3574 !ha->flags.reset_marker; bus++) {
3575 if (ha->bus_settings[bus].reset_marker) {
3576 ha->bus_settings[bus].reset_marker = 0;
3577 qla1280_marker(ha, bus, 0, 0,
3584 LEAVE("qla1280_rst_aen");
3589 * qla1280_status_entry
3590 * Processes received ISP status entry.
3593 * ha = adapter block pointer.
3594 * pkt = entry pointer.
3595 * done_q = done queue.
3598 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3599 struct list_head *done_q)
3603 struct scsi_cmnd *cmd;
3604 uint32_t handle = le32_to_cpu(pkt->handle);
3605 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3606 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3608 ENTER("qla1280_status_entry");
3610 /* Validate handle. */
3611 if (handle < MAX_OUTSTANDING_COMMANDS)
3612 sp = ha->outstanding_cmds[handle];
3617 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3621 /* Free outstanding command slot. */
3622 ha->outstanding_cmds[handle] = NULL;
3626 if (comp_status || scsi_status) {
3627 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3628 "0x%x, handle = 0x%x\n", comp_status,
3629 scsi_status, handle);
3632 /* Target busy or queue full */
3633 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3634 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3635 CMD_RESULT(cmd) = scsi_status & 0xff;
3638 /* Save ISP completion status */
3639 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3641 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3642 if (comp_status != CS_ARS_FAILED) {
3643 uint16_t req_sense_length =
3644 le16_to_cpu(pkt->req_sense_length);
3645 if (req_sense_length < CMD_SNSLEN(cmd))
3646 sense_sz = req_sense_length;
3649 * scsi_cmnd->sense_buffer is
3650 * 64 bytes, why only copy 63?
3651 * This looks wrong! /Jes
3653 sense_sz = CMD_SNSLEN(cmd) - 1;
3655 memcpy(cmd->sense_buffer,
3656 &pkt->req_sense_data, sense_sz);
3659 memset(cmd->sense_buffer + sense_sz, 0,
3660 SCSI_SENSE_BUFFERSIZE - sense_sz);
3662 dprintk(2, "qla1280_status_entry: Check "
3663 "condition Sense data, b %i, t %i, "
3664 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3667 qla1280_dump_buffer(2,
3668 (char *)cmd->sense_buffer,
3673 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3675 /* Place command on done queue. */
3676 list_add_tail(&sp->list, done_q);
3678 LEAVE("qla1280_status_entry");
3682 * qla1280_error_entry
3683 * Processes error entry.
3686 * ha = adapter block pointer.
3687 * pkt = entry pointer.
3688 * done_q = done queue.
3691 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3692 struct list_head *done_q)
3695 uint32_t handle = le32_to_cpu(pkt->handle);
3697 ENTER("qla1280_error_entry");
3699 if (pkt->entry_status & BIT_3)
3700 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3701 else if (pkt->entry_status & BIT_2)
3702 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3703 else if (pkt->entry_status & BIT_1)
3704 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3706 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3708 /* Validate handle. */
3709 if (handle < MAX_OUTSTANDING_COMMANDS)
3710 sp = ha->outstanding_cmds[handle];
3715 /* Free outstanding command slot. */
3716 ha->outstanding_cmds[handle] = NULL;
3718 /* Bad payload or header */
3719 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3720 /* Bad payload or header, set error status. */
3721 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3722 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3723 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3724 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3726 /* Set error status. */
3727 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3730 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3732 /* Place command on done queue. */
3733 list_add_tail(&sp->list, done_q);
3735 #ifdef QLA_64BIT_PTR
3736 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3737 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3741 LEAVE("qla1280_error_entry");
3746 * Resets ISP and aborts all outstanding commands.
3749 * ha = adapter block pointer.
3755 qla1280_abort_isp(struct scsi_qla_host *ha)
3757 struct device_reg __iomem *reg = ha->iobase;
3763 ENTER("qla1280_abort_isp");
3765 if (ha->flags.abort_isp_active || !ha->flags.online)
3768 ha->flags.abort_isp_active = 1;
3770 /* Disable ISP interrupts. */
3771 qla1280_disable_intrs(ha);
3772 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3773 RD_REG_WORD(®->id_l);
3775 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3777 /* Dequeue all commands in outstanding command list. */
3778 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3779 struct scsi_cmnd *cmd;
3780 sp = ha->outstanding_cmds[cnt];
3783 CMD_RESULT(cmd) = DID_RESET << 16;
3784 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
3785 ha->outstanding_cmds[cnt] = NULL;
3786 list_add_tail(&sp->list, &ha->done_q);
3792 status = qla1280_load_firmware(ha);
3796 /* Setup adapter based on NVRAM parameters. */
3797 qla1280_nvram_config (ha);
3799 status = qla1280_init_rings(ha);
3803 /* Issue SCSI reset. */
3804 for (bus = 0; bus < ha->ports; bus++)
3805 qla1280_bus_reset(ha, bus);
3807 ha->flags.abort_isp_active = 0;
3811 "qla1280: ISP error recovery failed, board disabled");
3812 qla1280_reset_adapter(ha);
3813 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3816 LEAVE("qla1280_abort_isp");
3822 * qla1280_debounce_register
3823 * Debounce register.
3826 * port = register address.
3832 qla1280_debounce_register(volatile u16 __iomem * addr)
3837 ret = RD_REG_WORD(addr);
3838 ret2 = RD_REG_WORD(addr);
3845 ret = RD_REG_WORD(addr);
3846 ret2 = RD_REG_WORD(addr);
3847 } while (ret != ret2);
3853 /************************************************************************
3854 * qla1280_check_for_dead_scsi_bus *
3856 * This routine checks for a dead SCSI bus *
3857 ************************************************************************/
3858 #define SET_SXP_BANK 0x0100
3859 #define SCSI_PHASE_INVALID 0x87FF
3861 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3863 uint16_t config_reg, scsi_control;
3864 struct device_reg __iomem *reg = ha->iobase;
3866 if (ha->bus_settings[bus].scsi_bus_dead) {
3867 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3868 config_reg = RD_REG_WORD(®->cfg_1);
3869 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
3870 scsi_control = RD_REG_WORD(®->scsiControlPins);
3871 WRT_REG_WORD(®->cfg_1, config_reg);
3872 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
3874 if (scsi_control == SCSI_PHASE_INVALID) {
3875 ha->bus_settings[bus].scsi_bus_dead = 1;
3876 return 1; /* bus is dead */
3878 ha->bus_settings[bus].scsi_bus_dead = 0;
3879 ha->bus_settings[bus].failed_reset_count = 0;
3882 return 0; /* bus is not dead */
3886 qla1280_get_target_parameters(struct scsi_qla_host *ha,
3887 struct scsi_device *device)
3889 uint16_t mb[MAILBOX_REGISTER_COUNT];
3890 int bus, target, lun;
3892 bus = device->channel;
3893 target = device->id;
3897 mb[0] = MBC_GET_TARGET_PARAMETERS;
3898 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3900 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3903 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3906 printk(KERN_CONT " Sync: period %d, offset %d",
3907 (mb[3] & 0xff), (mb[3] >> 8));
3909 printk(KERN_CONT ", Wide");
3910 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3911 printk(KERN_CONT ", DT");
3913 printk(KERN_CONT " Async");
3915 if (device->simple_tags)
3916 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);
3917 printk(KERN_CONT "\n");
3923 __qla1280_dump_buffer(char *b, int size)
3928 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3929 "Bh Ch Dh Eh Fh\n");
3930 printk(KERN_DEBUG "---------------------------------------------"
3931 "------------------\n");
3933 for (cnt = 0; cnt < size;) {
3936 printk("0x%02x", c);
3947 /**************************************************************************
3948 * ql1280_print_scsi_cmd
3950 **************************************************************************/
3952 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
3954 struct scsi_qla_host *ha;
3955 struct Scsi_Host *host = CMD_HOST(cmd);
3957 /* struct scatterlist *sg; */
3960 ha = (struct scsi_qla_host *)host->hostdata;
3962 sp = (struct srb *)CMD_SP(cmd);
3963 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
3964 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
3965 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
3968 for (i = 0; i < cmd->cmd_len; i++) {
3969 printk("0x%02x ", cmd->cmnd[i]);
3971 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
3972 printk(" request buffer=0x%p, request buffer len=0x%x\n",
3973 scsi_sglist(cmd), scsi_bufflen(cmd));
3976 sg = (struct scatterlist *) cmd->request_buffer;
3977 printk(" SG buffer: \n");
3978 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
3980 printk(" tag=%d, transfersize=0x%x \n",
3981 scsi_cmd_to_rq(cmd)->tag, cmd->transfersize);
3982 printk(" SP=0x%p\n", CMD_SP(cmd));
3983 printk(" underflow size = 0x%x, direction=0x%x\n",
3984 cmd->underflow, cmd->sc_data_direction);
3987 /**************************************************************************
3988 * ql1280_dump_device
3990 **************************************************************************/
3992 ql1280_dump_device(struct scsi_qla_host *ha)
3995 struct scsi_cmnd *cp;
3999 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4001 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4002 if ((sp = ha->outstanding_cmds[i]) == NULL)
4004 if ((cp = sp->cmd) == NULL)
4006 qla1280_print_scsi_cmd(1, cp);
4021 struct setup_tokens {
4026 static struct setup_tokens setup_token[] __initdata =
4028 { "nvram", TOKEN_NVRAM },
4029 { "sync", TOKEN_SYNC },
4030 { "wide", TOKEN_WIDE },
4031 { "ppr", TOKEN_PPR },
4032 { "verbose", TOKEN_VERBOSE },
4033 { "debug", TOKEN_DEBUG },
4037 /**************************************************************************
4040 * Handle boot parameters. This really needs to be changed so one
4041 * can specify per adapter parameters.
4042 **************************************************************************/
4044 qla1280_setup(char *s)
4052 while (cp && (ptr = strchr(cp, ':'))) {
4054 if (!strcmp(ptr, "yes")) {
4057 } else if (!strcmp(ptr, "no")) {
4061 val = simple_strtoul(ptr, &ptr, 0);
4063 switch ((toke = qla1280_get_token(cp))) {
4066 driver_setup.no_nvram = 1;
4070 driver_setup.no_sync = 1;
4071 else if (val != 0x10000)
4072 driver_setup.sync_mask = val;
4076 driver_setup.no_wide = 1;
4077 else if (val != 0x10000)
4078 driver_setup.wide_mask = val;
4082 driver_setup.no_ppr = 1;
4083 else if (val != 0x10000)
4084 driver_setup.ppr_mask = val;
4087 qla1280_verbose = val;
4090 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4094 cp = strchr(ptr, ';');
4106 qla1280_get_token(char *str)
4112 sep = strchr(str, ':');
4115 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
4116 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4117 ret = setup_token[i].val;
4127 static struct scsi_host_template qla1280_driver_template = {
4128 .module = THIS_MODULE,
4129 .proc_name = "qla1280",
4130 .name = "Qlogic ISP 1280/12160",
4131 .info = qla1280_info,
4132 .slave_configure = qla1280_slave_configure,
4133 .queuecommand = qla1280_queuecommand,
4134 .eh_abort_handler = qla1280_eh_abort,
4135 .eh_device_reset_handler= qla1280_eh_device_reset,
4136 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4137 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4138 .bios_param = qla1280_biosparam,
4139 .can_queue = MAX_OUTSTANDING_COMMANDS,
4141 .sg_tablesize = SG_ALL,
4146 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4148 int devnum = id->driver_data;
4149 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4150 struct Scsi_Host *host;
4151 struct scsi_qla_host *ha;
4152 int error = -ENODEV;
4154 /* Bypass all AMI SUBSYS VENDOR IDs */
4155 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4157 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4161 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4162 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4164 if (pci_enable_device(pdev)) {
4166 "qla1280: Failed to enabled pci device, aborting.\n");
4170 pci_set_master(pdev);
4173 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4176 "qla1280: Failed to register host, aborting.\n");
4177 goto error_disable_device;
4180 ha = (struct scsi_qla_host *)host->hostdata;
4181 memset(ha, 0, sizeof(struct scsi_qla_host));
4184 ha->devnum = devnum; /* specifies microcode load address */
4186 #ifdef QLA_64BIT_PTR
4187 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
4188 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4189 printk(KERN_WARNING "scsi(%li): Unable to set a "
4190 "suitable DMA mask - aborting\n", ha->host_no);
4192 goto error_put_host;
4195 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4198 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4199 printk(KERN_WARNING "scsi(%li): Unable to set a "
4200 "suitable DMA mask - aborting\n", ha->host_no);
4202 goto error_put_host;
4206 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
4207 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4208 &ha->request_dma, GFP_KERNEL);
4209 if (!ha->request_ring) {
4210 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4211 goto error_put_host;
4214 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
4215 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4216 &ha->response_dma, GFP_KERNEL);
4217 if (!ha->response_ring) {
4218 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4219 goto error_free_request_ring;
4222 ha->ports = bdp->numPorts;
4225 ha->host_no = host->host_no;
4227 host->irq = pdev->irq;
4228 host->max_channel = bdp->numPorts - 1;
4229 host->max_lun = MAX_LUNS - 1;
4230 host->max_id = MAX_TARGETS;
4231 host->max_sectors = 1024;
4232 host->unique_id = host->host_no;
4236 #if MEMORY_MAPPED_IO
4237 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
4239 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4240 goto error_free_response_ring;
4243 host->base = (unsigned long)ha->mmpbase;
4244 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4246 host->io_port = pci_resource_start(ha->pdev, 0);
4247 if (!request_region(host->io_port, 0xff, "qla1280")) {
4248 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4249 "0x%04lx-0x%04lx - already in use\n",
4250 host->io_port, host->io_port + 0xff);
4251 goto error_free_response_ring;
4254 ha->iobase = (struct device_reg *)host->io_port;
4257 INIT_LIST_HEAD(&ha->done_q);
4259 /* Disable ISP interrupts. */
4260 qla1280_disable_intrs(ha);
4262 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
4264 printk("qla1280 : Failed to reserve interrupt %d already "
4265 "in use\n", pdev->irq);
4266 goto error_release_region;
4269 /* load the F/W, read paramaters, and init the H/W */
4270 if (qla1280_initialize_adapter(ha)) {
4271 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4272 goto error_free_irq;
4275 /* set our host ID (need to do something about our two IDs) */
4276 host->this_id = ha->bus_settings[0].id;
4278 pci_set_drvdata(pdev, host);
4280 error = scsi_add_host(host, &pdev->dev);
4282 goto error_disable_adapter;
4283 scsi_scan_host(host);
4287 error_disable_adapter:
4288 qla1280_disable_intrs(ha);
4290 free_irq(pdev->irq, ha);
4291 error_release_region:
4292 #if MEMORY_MAPPED_IO
4293 iounmap(ha->mmpbase);
4295 release_region(host->io_port, 0xff);
4297 error_free_response_ring:
4298 dma_free_coherent(&ha->pdev->dev,
4299 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4300 ha->response_ring, ha->response_dma);
4301 error_free_request_ring:
4302 dma_free_coherent(&ha->pdev->dev,
4303 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4304 ha->request_ring, ha->request_dma);
4306 scsi_host_put(host);
4307 error_disable_device:
4308 pci_disable_device(pdev);
4315 qla1280_remove_one(struct pci_dev *pdev)
4317 struct Scsi_Host *host = pci_get_drvdata(pdev);
4318 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4320 scsi_remove_host(host);
4322 qla1280_disable_intrs(ha);
4324 free_irq(pdev->irq, ha);
4326 #if MEMORY_MAPPED_IO
4327 iounmap(ha->mmpbase);
4329 release_region(host->io_port, 0xff);
4332 dma_free_coherent(&ha->pdev->dev,
4333 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4334 ha->request_ring, ha->request_dma);
4335 dma_free_coherent(&ha->pdev->dev,
4336 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4337 ha->response_ring, ha->response_dma);
4339 pci_disable_device(pdev);
4341 scsi_host_put(host);
4344 static struct pci_driver qla1280_pci_driver = {
4346 .id_table = qla1280_pci_tbl,
4347 .probe = qla1280_probe_one,
4348 .remove = qla1280_remove_one,
4354 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4356 "qla1280: struct srb too big, aborting\n");
4362 * If we are called as a module, the qla1280 pointer may not be null
4363 * and it would point to our bootup string, just like on the lilo
4364 * command line. IF not NULL, then process this config string with
4368 * To add options at boot time add a line to your lilo.conf file like:
4369 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4370 * which will result in the first four devices on the first two
4371 * controllers being set to a tagged queue depth of 32.
4374 qla1280_setup(qla1280);
4377 return pci_register_driver(&qla1280_pci_driver);
4385 pci_unregister_driver(&qla1280_pci_driver);
4386 /* release any allocated firmware images */
4387 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4388 release_firmware(qla1280_fw_tbl[i].fw);
4389 qla1280_fw_tbl[i].fw = NULL;
4393 module_init(qla1280_init);
4394 module_exit(qla1280_exit);
4396 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4397 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4398 MODULE_LICENSE("GPL");
4399 MODULE_FIRMWARE("qlogic/1040.bin");
4400 MODULE_FIRMWARE("qlogic/1280.bin");
4401 MODULE_FIRMWARE("qlogic/12160.bin");
4402 MODULE_VERSION(QLA1280_VERSION);