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);
480 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
481 #define CMD_CDBP(Cmnd) Cmnd->cmnd
482 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
483 #define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
484 #define CMD_RESULT(Cmnd) Cmnd->result
485 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
487 #define CMD_HOST(Cmnd) Cmnd->device->host
488 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
489 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
490 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
493 /*****************************************/
494 /* ISP Boards supported by this driver */
495 /*****************************************/
498 char *name; /* Board ID String */
499 int numPorts; /* Number of SCSI ports */
500 int fw_index; /* index into qla1280_fw_tbl for firmware */
503 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
504 static struct pci_device_id qla1280_pci_tbl[] = {
505 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
506 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
507 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
508 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
509 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
510 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
511 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
512 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
513 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
514 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
515 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
516 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
519 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
521 static DEFINE_MUTEX(qla1280_firmware_mutex);
525 const struct firmware *fw;
528 #define QL_NUM_FW_IMAGES 3
530 static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
531 {"qlogic/1040.bin", NULL}, /* image 0 */
532 {"qlogic/1280.bin", NULL}, /* image 1 */
533 {"qlogic/12160.bin", NULL}, /* image 2 */
536 /* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
537 static struct qla_boards ql1280_board_tbl[] = {
538 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
539 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
540 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
541 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
542 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
543 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
544 {.name = " ", .numPorts = 0, .fw_index = -1},
547 static int qla1280_verbose = 1;
550 static int ql_debug_level = 1;
551 #define dprintk(level, format, a...) \
552 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
553 #define qla1280_dump_buffer(level, buf, size) \
554 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
555 #define qla1280_print_scsi_cmd(level, cmd) \
556 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
558 #define ql_debug_level 0
559 #define dprintk(level, format, a...) do{}while(0)
560 #define qla1280_dump_buffer(a, b, c) do{}while(0)
561 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
564 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
565 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
566 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
567 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
570 static int qla1280_read_nvram(struct scsi_qla_host *ha)
577 ENTER("qla1280_read_nvram");
579 if (driver_setup.no_nvram)
582 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
584 wptr = (uint16_t *)&ha->nvram;
587 for (cnt = 0; cnt < 3; cnt++) {
588 *wptr = qla1280_get_nvram_word(ha, cnt);
589 chksum += *wptr & 0xff;
590 chksum += (*wptr >> 8) & 0xff;
594 if (nv->id0 != 'I' || nv->id1 != 'S' ||
595 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
596 dprintk(2, "Invalid nvram ID or version!\n");
599 for (; cnt < sizeof(struct nvram); cnt++) {
600 *wptr = qla1280_get_nvram_word(ha, cnt);
601 chksum += *wptr & 0xff;
602 chksum += (*wptr >> 8) & 0xff;
607 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
608 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
613 if (!driver_setup.no_nvram)
614 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
615 "validate NVRAM checksum, using default "
616 "settings\n", ha->host_no);
621 /* The firmware interface is, um, interesting, in that the
622 * actual firmware image on the chip is little endian, thus,
623 * the process of taking that image to the CPU would end up
624 * little endian. However, the firmware interface requires it
625 * to be read a word (two bytes) at a time.
627 * The net result of this would be that the word (and
628 * doubleword) quantities in the firmware would be correct, but
629 * the bytes would be pairwise reversed. Since most of the
630 * firmware quantities are, in fact, bytes, we do an extra
631 * le16_to_cpu() in the firmware read routine.
633 * The upshot of all this is that the bytes in the firmware
634 * are in the correct places, but the 16 and 32 bit quantities
635 * are still in little endian format. We fix that up below by
636 * doing extra reverses on them */
637 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
638 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
639 for(i = 0; i < MAX_BUSES; i++) {
640 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
641 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
643 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
644 LEAVE("qla1280_read_nvram");
649 /**************************************************************************
651 * Return a string describing the driver.
652 **************************************************************************/
654 qla1280_info(struct Scsi_Host *host)
656 static char qla1280_scsi_name_buffer[125];
658 struct scsi_qla_host *ha;
659 struct qla_boards *bdp;
661 bp = &qla1280_scsi_name_buffer[0];
662 ha = (struct scsi_qla_host *)host->hostdata;
663 bdp = &ql1280_board_tbl[ha->devnum];
664 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
667 "QLogic %s PCI to SCSI Host Adapter\n"
668 " Firmware version: %2d.%02d.%02d, Driver version %s",
669 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
674 /**************************************************************************
675 * qla1280_queuecommand
676 * Queue a command to the controller.
679 * The mid-level driver tries to ensures that queuecommand never gets invoked
680 * concurrently with itself or the interrupt handler (although the
681 * interrupt handler may call this routine as part of request-completion
682 * handling). Unfortunately, it sometimes calls the scheduler in interrupt
683 * context which is a big NO! NO!.
684 **************************************************************************/
685 static int qla1280_queuecommand_lck(struct scsi_cmnd *cmd)
687 struct Scsi_Host *host = cmd->device->host;
688 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
689 struct srb *sp = scsi_cmd_priv(cmd);
695 CMD_HANDLE(cmd) = (unsigned char *)NULL;
697 qla1280_print_scsi_cmd(5, cmd);
701 * Using 64 bit commands if the PCI bridge doesn't support it is a
702 * bit wasteful, however this should really only happen if one's
703 * PCI controller is completely broken, like the BCM1250. For
704 * sane hardware this is not an issue.
706 status = qla1280_64bit_start_scsi(ha, sp);
708 status = qla1280_32bit_start_scsi(ha, sp);
713 static DEF_SCSI_QCMD(qla1280_queuecommand)
722 static void qla1280_mailbox_timeout(struct timer_list *t)
724 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
725 struct device_reg __iomem *reg;
728 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
729 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
730 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
731 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
732 complete(ha->mailbox_wait);
736 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
737 struct completion *wait)
740 struct scsi_cmnd *cmd = sp->cmd;
742 spin_unlock_irq(ha->host->host_lock);
743 wait_for_completion_timeout(wait, 4*HZ);
744 spin_lock_irq(ha->host->host_lock);
746 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
754 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
756 DECLARE_COMPLETION_ONSTACK(wait);
759 return _qla1280_wait_for_single_command(ha, sp, &wait);
763 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
768 struct scsi_cmnd *cmd;
773 * Wait for all commands with the designated bus/target
774 * to be completed by the firmware
776 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
777 sp = ha->outstanding_cmds[cnt];
781 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
783 if (target >= 0 && SCSI_TCN_32(cmd) != target)
786 status = qla1280_wait_for_single_command(ha, sp);
787 if (status == FAILED)
794 /**************************************************************************
795 * qla1280_error_action
796 * The function will attempt to perform a specified error action and
797 * wait for the results (or time out).
800 * cmd = Linux SCSI command packet of the command that cause the
802 * action = error action to take (see action_t)
807 **************************************************************************/
809 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
811 struct scsi_qla_host *ha;
812 int bus, target, lun;
817 int wait_for_target = -1;
818 DECLARE_COMPLETION_ONSTACK(wait);
820 ENTER("qla1280_error_action");
822 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
823 sp = scsi_cmd_priv(cmd);
824 bus = SCSI_BUS_32(cmd);
825 target = SCSI_TCN_32(cmd);
826 lun = SCSI_LUN_32(cmd);
828 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
829 RD_REG_WORD(&ha->iobase->istatus));
831 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
832 RD_REG_WORD(&ha->iobase->host_cmd),
833 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
836 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
837 "Handle=0x%p, action=0x%x\n",
838 ha->host_no, cmd, CMD_HANDLE(cmd), action);
841 * Check to see if we have the command in the outstanding_cmds[]
842 * array. If not then it must have completed before this error
843 * action was initiated. If the error_action isn't ABORT_COMMAND
844 * then the driver must proceed with the requested action.
847 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
848 if (sp == ha->outstanding_cmds[i]) {
850 sp->wait = &wait; /* we'll wait for it to complete */
855 if (found < 0) { /* driver doesn't have command */
857 if (qla1280_verbose) {
859 "scsi(%ld:%d:%d:%d): specified command has "
860 "already completed.\n", ha->host_no, bus,
868 dprintk(1, "qla1280: RISC aborting command\n");
870 * The abort might fail due to race when the host_lock
871 * is released to issue the abort. As such, we
872 * don't bother to check the return status.
875 qla1280_abort_command(ha, sp, found);
881 "scsi(%ld:%d:%d:%d): Queueing device reset "
882 "command.\n", ha->host_no, bus, target, lun);
883 if (qla1280_device_reset(ha, bus, target) == 0) {
884 /* issued device reset, set wait conditions */
886 wait_for_target = target;
892 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
893 "reset.\n", ha->host_no, bus);
894 if (qla1280_bus_reset(ha, bus) == 0) {
895 /* issued bus reset, set wait conditions */
901 dprintk(1, "RESET invalid action %d\n", action);
906 * At this point, the host_lock has been released and retaken
907 * by the issuance of the mailbox command.
908 * Wait for the command passed in by the mid-layer if it
909 * was found by the driver. It might have been returned
910 * between eh recovery steps, hence the check of the "found"
915 result = _qla1280_wait_for_single_command(ha, sp, &wait);
917 if (action == ABORT_COMMAND && result != SUCCESS) {
919 "scsi(%li:%i:%i:%i): "
920 "Unable to abort command!\n",
921 ha->host_no, bus, target, lun);
925 * If the command passed in by the mid-layer has been
926 * returned by the board, then wait for any additional
927 * commands which are supposed to complete based upon
930 * All commands are unconditionally returned during a
931 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
934 if (result == SUCCESS && wait_for_bus >= 0) {
935 result = qla1280_wait_for_pending_commands(ha,
936 wait_for_bus, wait_for_target);
939 dprintk(1, "RESET returning %d\n", result);
941 LEAVE("qla1280_error_action");
945 /**************************************************************************
947 * Abort the specified SCSI command(s).
948 **************************************************************************/
950 qla1280_eh_abort(struct scsi_cmnd * cmd)
954 spin_lock_irq(cmd->device->host->host_lock);
955 rc = qla1280_error_action(cmd, ABORT_COMMAND);
956 spin_unlock_irq(cmd->device->host->host_lock);
961 /**************************************************************************
962 * qla1280_device_reset
963 * Reset the specified SCSI device
964 **************************************************************************/
966 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
970 spin_lock_irq(cmd->device->host->host_lock);
971 rc = qla1280_error_action(cmd, DEVICE_RESET);
972 spin_unlock_irq(cmd->device->host->host_lock);
977 /**************************************************************************
979 * Reset the specified bus.
980 **************************************************************************/
982 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
986 spin_lock_irq(cmd->device->host->host_lock);
987 rc = qla1280_error_action(cmd, BUS_RESET);
988 spin_unlock_irq(cmd->device->host->host_lock);
993 /**************************************************************************
994 * qla1280_adapter_reset
995 * Reset the specified adapter (both channels)
996 **************************************************************************/
998 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1001 struct Scsi_Host *shost = cmd->device->host;
1002 struct scsi_qla_host *ha = (struct scsi_qla_host *)shost->hostdata;
1004 spin_lock_irq(shost->host_lock);
1005 if (qla1280_verbose) {
1007 "scsi(%ld): Issued ADAPTER RESET\n",
1009 printk(KERN_INFO "scsi(%ld): I/O processing will "
1010 "continue automatically\n", ha->host_no);
1012 ha->flags.reset_active = 1;
1014 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
1018 ha->flags.reset_active = 0;
1020 spin_unlock_irq(shost->host_lock);
1026 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1027 sector_t capacity, int geom[])
1029 int heads, sectors, cylinders;
1033 cylinders = (unsigned long)capacity / (heads * sectors);
1034 if (cylinders > 1024) {
1037 cylinders = (unsigned long)capacity / (heads * sectors);
1038 /* if (cylinders > 1023)
1039 cylinders = 1023; */
1044 geom[2] = cylinders;
1050 /* disable risc and host interrupts */
1052 qla1280_disable_intrs(struct scsi_qla_host *ha)
1054 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1055 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1058 /* enable risc and host interrupts */
1060 qla1280_enable_intrs(struct scsi_qla_host *ha)
1062 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1063 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1066 /**************************************************************************
1067 * qla1280_intr_handler
1068 * Handles the H/W interrupt
1069 **************************************************************************/
1071 qla1280_intr_handler(int irq, void *dev_id)
1073 struct scsi_qla_host *ha;
1074 struct device_reg __iomem *reg;
1078 ENTER_INTR ("qla1280_intr_handler");
1079 ha = (struct scsi_qla_host *)dev_id;
1081 spin_lock(ha->host->host_lock);
1086 qla1280_disable_intrs(ha);
1088 data = qla1280_debounce_register(®->istatus);
1089 /* Check for pending interrupts. */
1090 if (data & RISC_INT) {
1091 qla1280_isr(ha, &ha->done_q);
1094 if (!list_empty(&ha->done_q))
1097 spin_unlock(ha->host->host_lock);
1099 qla1280_enable_intrs(ha);
1101 LEAVE_INTR("qla1280_intr_handler");
1102 return IRQ_RETVAL(handled);
1107 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1110 uint16_t mb[MAILBOX_REGISTER_COUNT];
1116 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1118 /* Set Target Parameters. */
1119 mb[0] = MBC_SET_TARGET_PARAMETERS;
1120 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1121 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1122 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1123 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1124 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1125 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1126 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1127 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1128 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1130 if (IS_ISP1x160(ha)) {
1131 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1132 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1133 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1134 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1137 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1139 mb[3] |= nv->bus[bus].target[target].sync_period;
1141 status = qla1280_mailbox_command(ha, mr, mb);
1143 /* Set Device Queue Parameters. */
1144 for (lun = 0; lun < MAX_LUNS; lun++) {
1145 mb[0] = MBC_SET_DEVICE_QUEUE;
1146 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1148 mb[2] = nv->bus[bus].max_queue_depth;
1149 mb[3] = nv->bus[bus].target[target].execution_throttle;
1150 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1154 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1155 "qla1280_set_target_parameters() failed\n",
1156 ha->host_no, bus, target);
1161 /**************************************************************************
1162 * qla1280_slave_configure
1165 * Determines the queue depth for a given device. There are two ways
1166 * a queue depth can be obtained for a tagged queueing device. One
1167 * way is the default queue depth which is determined by whether
1168 * If it is defined, then it is used
1169 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1170 * default queue depth (dependent on the number of hardware SCBs).
1171 **************************************************************************/
1173 qla1280_slave_configure(struct scsi_device *device)
1175 struct scsi_qla_host *ha;
1176 int default_depth = 3;
1177 int bus = device->channel;
1178 int target = device->id;
1181 unsigned long flags;
1183 ha = (struct scsi_qla_host *)device->host->hostdata;
1186 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1189 if (device->tagged_supported &&
1190 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1191 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1193 scsi_change_queue_depth(device, default_depth);
1196 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1197 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1198 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1200 if (driver_setup.no_sync ||
1201 (driver_setup.sync_mask &&
1202 (~driver_setup.sync_mask & (1 << target))))
1203 nv->bus[bus].target[target].parameter.enable_sync = 0;
1204 if (driver_setup.no_wide ||
1205 (driver_setup.wide_mask &&
1206 (~driver_setup.wide_mask & (1 << target))))
1207 nv->bus[bus].target[target].parameter.enable_wide = 0;
1208 if (IS_ISP1x160(ha)) {
1209 if (driver_setup.no_ppr ||
1210 (driver_setup.ppr_mask &&
1211 (~driver_setup.ppr_mask & (1 << target))))
1212 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1215 spin_lock_irqsave(ha->host->host_lock, flags);
1216 if (nv->bus[bus].target[target].parameter.enable_sync)
1217 status = qla1280_set_target_parameters(ha, bus, target);
1218 qla1280_get_target_parameters(ha, device);
1219 spin_unlock_irqrestore(ha->host->host_lock, flags);
1226 * Process completed commands.
1229 * ha = adapter block pointer.
1232 qla1280_done(struct scsi_qla_host *ha)
1235 struct list_head *done_q;
1237 struct scsi_cmnd *cmd;
1239 ENTER("qla1280_done");
1241 done_q = &ha->done_q;
1243 while (!list_empty(done_q)) {
1244 sp = list_entry(done_q->next, struct srb, list);
1246 list_del(&sp->list);
1249 bus = SCSI_BUS_32(cmd);
1250 target = SCSI_TCN_32(cmd);
1252 switch ((CMD_RESULT(cmd) >> 16)) {
1254 /* Issue marker command. */
1255 if (!ha->flags.abort_isp_active)
1256 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1259 sp->flags &= ~SRB_ABORT_PENDING;
1260 sp->flags |= SRB_ABORTED;
1266 /* Release memory used for this I/O */
1267 scsi_dma_unmap(cmd);
1269 /* Call the mid-level driver interrupt handler */
1272 if (sp->wait == NULL)
1277 LEAVE("qla1280_done");
1281 * Translates a ISP error to a Linux SCSI error
1284 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1286 int host_status = DID_ERROR;
1287 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1288 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1289 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1290 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1291 #if DEBUG_QLA1280_INTR
1292 static char *reason[] = {
1304 #endif /* DEBUG_QLA1280_INTR */
1306 ENTER("qla1280_return_status");
1308 #if DEBUG_QLA1280_INTR
1310 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1315 switch (comp_status) {
1317 host_status = DID_OK;
1321 if (!(state_flags & SF_GOT_BUS))
1322 host_status = DID_NO_CONNECT;
1323 else if (!(state_flags & SF_GOT_TARGET))
1324 host_status = DID_BAD_TARGET;
1325 else if (!(state_flags & SF_SENT_CDB))
1326 host_status = DID_ERROR;
1327 else if (!(state_flags & SF_TRANSFERRED_DATA))
1328 host_status = DID_ERROR;
1329 else if (!(state_flags & SF_GOT_STATUS))
1330 host_status = DID_ERROR;
1331 else if (!(state_flags & SF_GOT_SENSE))
1332 host_status = DID_ERROR;
1336 host_status = DID_RESET;
1340 host_status = DID_ABORT;
1344 host_status = DID_TIME_OUT;
1347 case CS_DATA_OVERRUN:
1348 dprintk(2, "Data overrun 0x%x\n", residual_length);
1349 dprintk(2, "qla1280_return_status: response packet data\n");
1350 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1351 host_status = DID_ERROR;
1354 case CS_DATA_UNDERRUN:
1355 if ((scsi_bufflen(cp) - residual_length) <
1358 "scsi: Underflow detected - retrying "
1360 host_status = DID_ERROR;
1362 scsi_set_resid(cp, residual_length);
1363 host_status = DID_OK;
1368 host_status = DID_ERROR;
1372 #if DEBUG_QLA1280_INTR
1373 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1374 reason[host_status], scsi_status);
1377 LEAVE("qla1280_return_status");
1379 return (scsi_status & 0xff) | (host_status << 16);
1382 /****************************************************************************/
1383 /* QLogic ISP1280 Hardware Support Functions. */
1384 /****************************************************************************/
1387 * qla1280_initialize_adapter
1391 * ha = adapter block pointer.
1397 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1399 struct device_reg __iomem *reg;
1402 unsigned long flags;
1404 ENTER("qla1280_initialize_adapter");
1406 /* Clear adapter flags. */
1407 ha->flags.online = 0;
1408 ha->flags.disable_host_adapter = 0;
1409 ha->flags.reset_active = 0;
1410 ha->flags.abort_isp_active = 0;
1412 /* TODO: implement support for the 1040 nvram format */
1414 driver_setup.no_nvram = 1;
1416 dprintk(1, "Configure PCI space for adapter...\n");
1420 /* Insure mailbox registers are free. */
1421 WRT_REG_WORD(®->semaphore, 0);
1422 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1423 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1424 RD_REG_WORD(®->host_cmd);
1426 if (qla1280_read_nvram(ha)) {
1427 dprintk(2, "qla1280_initialize_adapter: failed to read "
1432 * It's necessary to grab the spin here as qla1280_mailbox_command
1433 * needs to be able to drop the lock unconditionally to wait
1436 spin_lock_irqsave(ha->host->host_lock, flags);
1438 status = qla1280_load_firmware(ha);
1440 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1445 /* Setup adapter based on NVRAM parameters. */
1446 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1447 qla1280_nvram_config(ha);
1449 if (ha->flags.disable_host_adapter) {
1454 status = qla1280_init_rings(ha);
1458 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1459 for (bus = 0; bus < ha->ports; bus++) {
1460 if (!ha->bus_settings[bus].disable_scsi_reset &&
1461 qla1280_bus_reset(ha, bus) &&
1462 qla1280_bus_reset(ha, bus))
1463 ha->bus_settings[bus].scsi_bus_dead = 1;
1466 ha->flags.online = 1;
1468 spin_unlock_irqrestore(ha->host->host_lock, flags);
1471 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1473 LEAVE("qla1280_initialize_adapter");
1478 * qla1280_request_firmware
1479 * Acquire firmware for chip. Retain in memory
1480 * for error recovery.
1483 * ha = adapter block pointer.
1486 * Pointer to firmware image or an error code
1487 * cast to pointer via ERR_PTR().
1489 static const struct firmware *
1490 qla1280_request_firmware(struct scsi_qla_host *ha)
1492 const struct firmware *fw;
1497 spin_unlock_irq(ha->host->host_lock);
1498 mutex_lock(&qla1280_firmware_mutex);
1500 index = ql1280_board_tbl[ha->devnum].fw_index;
1501 fw = qla1280_fw_tbl[index].fw;
1505 fwname = qla1280_fw_tbl[index].fwname;
1506 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1509 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1514 if ((fw->size % 2) || (fw->size < 6)) {
1515 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1517 release_firmware(fw);
1518 fw = ERR_PTR(-EINVAL);
1522 qla1280_fw_tbl[index].fw = fw;
1525 ha->fwver1 = fw->data[0];
1526 ha->fwver2 = fw->data[1];
1527 ha->fwver3 = fw->data[2];
1529 mutex_unlock(&qla1280_firmware_mutex);
1530 spin_lock_irq(ha->host->host_lock);
1536 * Test chip for proper operation.
1539 * ha = adapter block pointer.
1545 qla1280_chip_diag(struct scsi_qla_host *ha)
1547 uint16_t mb[MAILBOX_REGISTER_COUNT];
1548 struct device_reg __iomem *reg = ha->iobase;
1552 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1554 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1556 /* Soft reset chip and wait for it to finish. */
1557 WRT_REG_WORD(®->ictrl, ISP_RESET);
1560 * We can't do a traditional PCI write flush here by reading
1561 * back the register. The card will not respond once the reset
1562 * is in action and we end up with a machine check exception
1563 * instead. Nothing to do but wait and hope for the best.
1564 * A portable pci_write_flush(pdev) call would be very useful here.
1567 data = qla1280_debounce_register(®->ictrl);
1569 * Yet another QLogic gem ;-(
1571 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1573 data = RD_REG_WORD(®->ictrl);
1579 /* Reset register cleared by chip reset. */
1580 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1582 WRT_REG_WORD(®->cfg_1, 0);
1584 /* Reset RISC and disable BIOS which
1585 allows RISC to execute out of RAM. */
1586 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1587 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1589 RD_REG_WORD(®->id_l); /* Flush PCI write */
1590 data = qla1280_debounce_register(®->mailbox0);
1593 * I *LOVE* this code!
1595 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1597 data = RD_REG_WORD(®->mailbox0);
1603 /* Check product ID of chip */
1604 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1606 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1607 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1608 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1609 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1610 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1611 printk(KERN_INFO "qla1280: Wrong product ID = "
1612 "0x%x,0x%x,0x%x,0x%x\n",
1613 RD_REG_WORD(®->mailbox1),
1614 RD_REG_WORD(®->mailbox2),
1615 RD_REG_WORD(®->mailbox3),
1616 RD_REG_WORD(®->mailbox4));
1621 * Enable ints early!!!
1623 qla1280_enable_intrs(ha);
1625 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1626 /* Wrap Incoming Mailboxes Test. */
1627 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1636 status = qla1280_mailbox_command(ha, 0xff, mb);
1640 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1641 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1643 printk(KERN_INFO "qla1280: Failed mbox check\n");
1647 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1650 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1655 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1657 /* enter with host_lock acquired */
1659 const struct firmware *fw;
1660 const __le16 *fw_data;
1661 uint16_t risc_address, risc_code_size;
1662 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1665 fw = qla1280_request_firmware(ha);
1669 fw_data = (const __le16 *)&fw->data[0];
1670 ha->fwstart = __le16_to_cpu(fw_data[2]);
1672 /* Load RISC code. */
1673 risc_address = ha->fwstart;
1674 fw_data = (const __le16 *)&fw->data[6];
1675 risc_code_size = (fw->size - 6) / 2;
1677 for (i = 0; i < risc_code_size; i++) {
1678 mb[0] = MBC_WRITE_RAM_WORD;
1679 mb[1] = risc_address + i;
1680 mb[2] = __le16_to_cpu(fw_data[i]);
1682 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1684 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1693 #ifdef QLA_64BIT_PTR
1694 #define LOAD_CMD MBC_LOAD_RAM_A64_ROM
1695 #define DUMP_CMD MBC_DUMP_RAM_A64_ROM
1696 #define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1698 #define LOAD_CMD MBC_LOAD_RAM
1699 #define DUMP_CMD MBC_DUMP_RAM
1700 #define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1703 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1705 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1707 /* enter with host_lock acquired */
1708 const struct firmware *fw;
1709 const __le16 *fw_data;
1710 uint16_t risc_address, risc_code_size;
1711 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1712 int err = 0, num, i;
1717 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1722 fw = qla1280_request_firmware(ha);
1726 fw_data = (const __le16 *)&fw->data[0];
1727 ha->fwstart = __le16_to_cpu(fw_data[2]);
1729 /* Load RISC code. */
1730 risc_address = ha->fwstart;
1731 fw_data = (const __le16 *)&fw->data[6];
1732 risc_code_size = (fw->size - 6) / 2;
1734 dprintk(1, "%s: DMA RISC code (%i) words\n",
1735 __func__, risc_code_size);
1738 while (risc_code_size > 0) {
1739 int warn __attribute__((unused)) = 0;
1743 if (cnt > risc_code_size)
1744 cnt = risc_code_size;
1746 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1748 fw_data, cnt, num, risc_address);
1749 for(i = 0; i < cnt; i++)
1750 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1753 mb[1] = risc_address;
1755 mb[3] = ha->request_dma & 0xffff;
1756 mb[2] = (ha->request_dma >> 16) & 0xffff;
1757 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1758 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1759 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1761 (void *)(long)ha->request_dma,
1762 mb[6], mb[7], mb[2], mb[3]);
1763 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1765 printk(KERN_ERR "scsi(%li): Failed to load partial "
1766 "segment of f\n", ha->host_no);
1772 mb[1] = risc_address;
1774 mb[3] = p_tbuf & 0xffff;
1775 mb[2] = (p_tbuf >> 16) & 0xffff;
1776 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1777 mb[6] = upper_32_bits(p_tbuf) >> 16;
1779 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1782 "Failed to dump partial segment of f/w\n");
1785 sp = (uint8_t *)ha->request_ring;
1786 for (i = 0; i < (cnt << 1); i++) {
1787 if (tbuf[i] != sp[i] && warn++ < 10) {
1788 printk(KERN_ERR "%s: FW compare error @ "
1789 "byte(0x%x) loop#=%x\n",
1791 printk(KERN_ERR "%s: FWbyte=%x "
1793 __func__, sp[i], tbuf[i]);
1798 risc_address += cnt;
1799 risc_code_size = risc_code_size - cnt;
1800 fw_data = fw_data + cnt;
1806 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1812 qla1280_start_firmware(struct scsi_qla_host *ha)
1814 uint16_t mb[MAILBOX_REGISTER_COUNT];
1817 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1820 /* Verify checksum of loaded RISC code. */
1821 mb[0] = MBC_VERIFY_CHECKSUM;
1822 /* mb[1] = ql12_risc_code_addr01; */
1823 mb[1] = ha->fwstart;
1824 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1826 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1830 /* Start firmware execution. */
1831 dprintk(1, "%s: start firmware running.\n", __func__);
1832 mb[0] = MBC_EXECUTE_FIRMWARE;
1833 mb[1] = ha->fwstart;
1834 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1836 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1844 qla1280_load_firmware(struct scsi_qla_host *ha)
1846 /* enter with host_lock taken */
1849 err = qla1280_chip_diag(ha);
1853 err = qla1280_load_firmware_pio(ha);
1855 err = qla1280_load_firmware_dma(ha);
1858 err = qla1280_start_firmware(ha);
1867 * ha = adapter block pointer.
1868 * ha->request_ring = request ring virtual address
1869 * ha->response_ring = response ring virtual address
1870 * ha->request_dma = request ring physical address
1871 * ha->response_dma = response ring physical address
1877 qla1280_init_rings(struct scsi_qla_host *ha)
1879 uint16_t mb[MAILBOX_REGISTER_COUNT];
1882 ENTER("qla1280_init_rings");
1884 /* Clear outstanding commands array. */
1885 memset(ha->outstanding_cmds, 0,
1886 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1888 /* Initialize request queue. */
1889 ha->request_ring_ptr = ha->request_ring;
1890 ha->req_ring_index = 0;
1891 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1892 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1893 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1894 mb[1] = REQUEST_ENTRY_CNT;
1895 mb[3] = ha->request_dma & 0xffff;
1896 mb[2] = (ha->request_dma >> 16) & 0xffff;
1898 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1899 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1900 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1901 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1903 /* Initialize response queue. */
1904 ha->response_ring_ptr = ha->response_ring;
1905 ha->rsp_ring_index = 0;
1906 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1907 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1908 mb[1] = RESPONSE_ENTRY_CNT;
1909 mb[3] = ha->response_dma & 0xffff;
1910 mb[2] = (ha->response_dma >> 16) & 0xffff;
1912 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1913 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1914 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1915 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1920 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1922 LEAVE("qla1280_init_rings");
1927 qla1280_print_settings(struct nvram *nv)
1929 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1930 nv->bus[0].config_1.initiator_id);
1931 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1932 nv->bus[1].config_1.initiator_id);
1934 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1935 nv->bus[0].bus_reset_delay);
1936 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1937 nv->bus[1].bus_reset_delay);
1939 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1940 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1941 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1942 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1944 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1945 nv->bus[0].config_2.async_data_setup_time);
1946 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1947 nv->bus[1].config_2.async_data_setup_time);
1949 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1950 nv->bus[0].config_2.req_ack_active_negation);
1951 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1952 nv->bus[1].config_2.req_ack_active_negation);
1954 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1955 nv->bus[0].config_2.data_line_active_negation);
1956 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1957 nv->bus[1].config_2.data_line_active_negation);
1959 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1960 nv->cntr_flags_1.disable_loading_risc_code);
1962 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1963 nv->cntr_flags_1.enable_64bit_addressing);
1965 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1966 nv->bus[0].selection_timeout);
1967 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1968 nv->bus[1].selection_timeout);
1970 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1971 nv->bus[0].max_queue_depth);
1972 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1973 nv->bus[1].max_queue_depth);
1977 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1979 struct nvram *nv = &ha->nvram;
1981 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
1982 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
1983 nv->bus[bus].target[target].parameter.tag_queuing = 1;
1984 nv->bus[bus].target[target].parameter.enable_sync = 1;
1985 #if 1 /* Some SCSI Processors do not seem to like this */
1986 nv->bus[bus].target[target].parameter.enable_wide = 1;
1988 nv->bus[bus].target[target].execution_throttle =
1989 nv->bus[bus].max_queue_depth - 1;
1990 nv->bus[bus].target[target].parameter.parity_checking = 1;
1991 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
1993 if (IS_ISP1x160(ha)) {
1994 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
1995 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
1996 nv->bus[bus].target[target].sync_period = 9;
1997 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
1998 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
1999 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2001 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2002 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2003 nv->bus[bus].target[target].sync_period = 10;
2008 qla1280_set_defaults(struct scsi_qla_host *ha)
2010 struct nvram *nv = &ha->nvram;
2013 dprintk(1, "Using defaults for NVRAM: \n");
2014 memset(nv, 0, sizeof(struct nvram));
2016 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2017 nv->firmware_feature.f.enable_fast_posting = 1;
2018 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2019 nv->termination.scsi_bus_0_control = 3;
2020 nv->termination.scsi_bus_1_control = 3;
2021 nv->termination.auto_term_support = 1;
2024 * Set default FIFO magic - What appropriate values would be here
2025 * is unknown. This is what I have found testing with 12160s.
2027 * Now, I would love the magic decoder ring for this one, the
2028 * header file provided by QLogic seems to be bogus or incomplete
2031 nv->isp_config.burst_enable = 1;
2033 nv->isp_config.fifo_threshold |= 3;
2035 nv->isp_config.fifo_threshold |= 4;
2037 if (IS_ISP1x160(ha))
2038 nv->isp_parameter = 0x01; /* fast memory enable */
2040 for (bus = 0; bus < MAX_BUSES; bus++) {
2041 nv->bus[bus].config_1.initiator_id = 7;
2042 nv->bus[bus].config_2.req_ack_active_negation = 1;
2043 nv->bus[bus].config_2.data_line_active_negation = 1;
2044 nv->bus[bus].selection_timeout = 250;
2045 nv->bus[bus].max_queue_depth = 32;
2047 if (IS_ISP1040(ha)) {
2048 nv->bus[bus].bus_reset_delay = 3;
2049 nv->bus[bus].config_2.async_data_setup_time = 6;
2050 nv->bus[bus].retry_delay = 1;
2052 nv->bus[bus].bus_reset_delay = 5;
2053 nv->bus[bus].config_2.async_data_setup_time = 8;
2056 for (target = 0; target < MAX_TARGETS; target++)
2057 qla1280_set_target_defaults(ha, bus, target);
2062 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2064 struct nvram *nv = &ha->nvram;
2065 uint16_t mb[MAILBOX_REGISTER_COUNT];
2069 /* Set Target Parameters. */
2070 mb[0] = MBC_SET_TARGET_PARAMETERS;
2071 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2074 * Do not enable sync and ppr for the initial INQUIRY run. We
2075 * enable this later if we determine the target actually
2078 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2079 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2081 if (IS_ISP1x160(ha))
2082 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2084 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2085 mb[3] |= nv->bus[bus].target[target].sync_period;
2086 status = qla1280_mailbox_command(ha, 0x0f, mb);
2088 /* Save Tag queuing enable flag. */
2089 flag = (BIT_0 << target);
2090 if (nv->bus[bus].target[target].parameter.tag_queuing)
2091 ha->bus_settings[bus].qtag_enables |= flag;
2093 /* Save Device enable flag. */
2094 if (IS_ISP1x160(ha)) {
2095 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2096 ha->bus_settings[bus].device_enables |= flag;
2097 ha->bus_settings[bus].lun_disables |= 0;
2099 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2100 ha->bus_settings[bus].device_enables |= flag;
2101 /* Save LUN disable flag. */
2102 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2103 ha->bus_settings[bus].lun_disables |= flag;
2106 /* Set Device Queue Parameters. */
2107 for (lun = 0; lun < MAX_LUNS; lun++) {
2108 mb[0] = MBC_SET_DEVICE_QUEUE;
2109 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2111 mb[2] = nv->bus[bus].max_queue_depth;
2112 mb[3] = nv->bus[bus].target[target].execution_throttle;
2113 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2120 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2122 struct nvram *nv = &ha->nvram;
2123 uint16_t mb[MAILBOX_REGISTER_COUNT];
2126 /* SCSI Reset Disable. */
2127 ha->bus_settings[bus].disable_scsi_reset =
2128 nv->bus[bus].config_1.scsi_reset_disable;
2131 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2132 mb[0] = MBC_SET_INITIATOR_ID;
2133 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2134 ha->bus_settings[bus].id;
2135 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2138 ha->bus_settings[bus].bus_reset_delay =
2139 nv->bus[bus].bus_reset_delay;
2141 /* Command queue depth per device. */
2142 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2144 /* Set target parameters. */
2145 for (target = 0; target < MAX_TARGETS; target++)
2146 status |= qla1280_config_target(ha, bus, target);
2152 qla1280_nvram_config(struct scsi_qla_host *ha)
2154 struct device_reg __iomem *reg = ha->iobase;
2155 struct nvram *nv = &ha->nvram;
2156 int bus, target, status = 0;
2157 uint16_t mb[MAILBOX_REGISTER_COUNT];
2159 ENTER("qla1280_nvram_config");
2161 if (ha->nvram_valid) {
2162 /* Always force AUTO sense for LINUX SCSI */
2163 for (bus = 0; bus < MAX_BUSES; bus++)
2164 for (target = 0; target < MAX_TARGETS; target++) {
2165 nv->bus[bus].target[target].parameter.
2166 auto_request_sense = 1;
2169 qla1280_set_defaults(ha);
2172 qla1280_print_settings(nv);
2174 /* Disable RISC load of firmware. */
2175 ha->flags.disable_risc_code_load =
2176 nv->cntr_flags_1.disable_loading_risc_code;
2178 if (IS_ISP1040(ha)) {
2179 uint16_t hwrev, cfg1, cdma_conf;
2181 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2183 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2184 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2186 /* Busted fifo, says mjacob. */
2187 if (hwrev != ISP_CFG0_1040A)
2188 cfg1 |= nv->isp_config.fifo_threshold << 4;
2190 cfg1 |= nv->isp_config.burst_enable << 2;
2191 WRT_REG_WORD(®->cfg_1, cfg1);
2193 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2194 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2196 uint16_t cfg1, term;
2198 /* Set ISP hardware DMA burst */
2199 cfg1 = nv->isp_config.fifo_threshold << 4;
2200 cfg1 |= nv->isp_config.burst_enable << 2;
2201 /* Enable DMA arbitration on dual channel controllers */
2204 WRT_REG_WORD(®->cfg_1, cfg1);
2206 /* Set SCSI termination. */
2207 WRT_REG_WORD(®->gpio_enable,
2208 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2209 term = nv->termination.scsi_bus_1_control;
2210 term |= nv->termination.scsi_bus_0_control << 2;
2211 term |= nv->termination.auto_term_support << 7;
2212 RD_REG_WORD(®->id_l); /* Flush PCI write */
2213 WRT_REG_WORD(®->gpio_data, term);
2215 RD_REG_WORD(®->id_l); /* Flush PCI write */
2217 /* ISP parameter word. */
2218 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2219 mb[1] = nv->isp_parameter;
2220 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2222 if (IS_ISP1x40(ha)) {
2223 /* clock rate - for qla1240 and older, only */
2224 mb[0] = MBC_SET_CLOCK_RATE;
2226 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2229 /* Firmware feature word. */
2230 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2231 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2232 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2233 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2234 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2236 /* Retry count and delay. */
2237 mb[0] = MBC_SET_RETRY_COUNT;
2238 mb[1] = nv->bus[0].retry_count;
2239 mb[2] = nv->bus[0].retry_delay;
2240 mb[6] = nv->bus[1].retry_count;
2241 mb[7] = nv->bus[1].retry_delay;
2242 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2243 BIT_1 | BIT_0, &mb[0]);
2245 /* ASYNC data setup time. */
2246 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2247 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2248 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2249 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2251 /* Active negation states. */
2252 mb[0] = MBC_SET_ACTIVE_NEGATION;
2254 if (nv->bus[0].config_2.req_ack_active_negation)
2256 if (nv->bus[0].config_2.data_line_active_negation)
2259 if (nv->bus[1].config_2.req_ack_active_negation)
2261 if (nv->bus[1].config_2.data_line_active_negation)
2263 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2265 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2266 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2267 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2270 mb[0] = MBC_SET_PCI_CONTROL;
2271 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2272 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2273 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2275 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2277 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2279 /* Selection timeout. */
2280 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2281 mb[1] = nv->bus[0].selection_timeout;
2282 mb[2] = nv->bus[1].selection_timeout;
2283 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2285 for (bus = 0; bus < ha->ports; bus++)
2286 status |= qla1280_config_bus(ha, bus);
2289 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2291 LEAVE("qla1280_nvram_config");
2296 * Get NVRAM data word
2297 * Calculates word position in NVRAM and calls request routine to
2298 * get the word from NVRAM.
2301 * ha = adapter block pointer.
2302 * address = NVRAM word address.
2308 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2313 nv_cmd = address << 16;
2314 nv_cmd |= NV_READ_OP;
2316 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2318 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2326 * Sends read command to NVRAM and gets data from NVRAM.
2329 * ha = adapter block pointer.
2330 * nv_cmd = Bit 26 = start bit
2331 * Bit 25, 24 = opcode
2332 * Bit 23-16 = address
2333 * Bit 15-0 = write data
2339 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2341 struct device_reg __iomem *reg = ha->iobase;
2346 /* Send command to NVRAM. */
2349 for (cnt = 0; cnt < 11; cnt++) {
2350 if (nv_cmd & BIT_31)
2351 qla1280_nv_write(ha, NV_DATA_OUT);
2353 qla1280_nv_write(ha, 0);
2357 /* Read data from NVRAM. */
2359 for (cnt = 0; cnt < 16; cnt++) {
2360 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2361 RD_REG_WORD(®->id_l); /* Flush PCI write */
2364 reg_data = RD_REG_WORD(®->nvram);
2365 if (reg_data & NV_DATA_IN)
2367 WRT_REG_WORD(®->nvram, NV_SELECT);
2368 RD_REG_WORD(®->id_l); /* Flush PCI write */
2372 /* Deselect chip. */
2374 WRT_REG_WORD(®->nvram, NV_DESELECT);
2375 RD_REG_WORD(®->id_l); /* Flush PCI write */
2382 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2384 struct device_reg __iomem *reg = ha->iobase;
2386 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2387 RD_REG_WORD(®->id_l); /* Flush PCI write */
2389 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2390 RD_REG_WORD(®->id_l); /* Flush PCI write */
2392 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2393 RD_REG_WORD(®->id_l); /* Flush PCI write */
2399 * Issue mailbox command and waits for completion.
2402 * ha = adapter block pointer.
2403 * mr = mailbox registers to load.
2404 * mb = data pointer for mailbox registers.
2407 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2413 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2415 struct device_reg __iomem *reg = ha->iobase;
2418 uint16_t *optr, *iptr;
2419 uint16_t __iomem *mptr;
2420 DECLARE_COMPLETION_ONSTACK(wait);
2422 ENTER("qla1280_mailbox_command");
2424 if (ha->mailbox_wait) {
2425 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2427 ha->mailbox_wait = &wait;
2430 * We really should start out by verifying that the mailbox is
2431 * available before starting sending the command data
2433 /* Load mailbox registers. */
2434 mptr = (uint16_t __iomem *) ®->mailbox0;
2436 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2438 WRT_REG_WORD(mptr, (*iptr));
2446 /* Issue set host interrupt command. */
2448 /* set up a timer just in case we're really jammed */
2449 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2450 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
2452 spin_unlock_irq(ha->host->host_lock);
2453 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2454 qla1280_debounce_register(®->istatus);
2456 wait_for_completion(&wait);
2457 del_timer_sync(&ha->mailbox_timer);
2459 spin_lock_irq(ha->host->host_lock);
2461 ha->mailbox_wait = NULL;
2463 /* Check for mailbox command timeout. */
2464 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2465 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2466 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2468 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2469 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2470 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2471 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2472 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2473 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2474 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2478 /* Load return mailbox registers. */
2480 iptr = (uint16_t *) &ha->mailbox_out[0];
2481 mr = MAILBOX_REGISTER_COUNT;
2482 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2484 if (ha->flags.reset_marker)
2485 qla1280_rst_aen(ha);
2488 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2489 "0x%x ****\n", mb[0]);
2491 LEAVE("qla1280_mailbox_command");
2497 * Polls ISP for interrupts.
2500 * ha = adapter block pointer.
2503 qla1280_poll(struct scsi_qla_host *ha)
2505 struct device_reg __iomem *reg = ha->iobase;
2509 /* ENTER("qla1280_poll"); */
2511 /* Check for pending interrupts. */
2512 data = RD_REG_WORD(®->istatus);
2513 if (data & RISC_INT)
2514 qla1280_isr(ha, &done_q);
2516 if (!ha->mailbox_wait) {
2517 if (ha->flags.reset_marker)
2518 qla1280_rst_aen(ha);
2521 if (!list_empty(&done_q))
2524 /* LEAVE("qla1280_poll"); */
2529 * Issue SCSI bus reset.
2532 * ha = adapter block pointer.
2533 * bus = SCSI bus number.
2539 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2541 uint16_t mb[MAILBOX_REGISTER_COUNT];
2542 uint16_t reset_delay;
2545 dprintk(3, "qla1280_bus_reset: entered\n");
2547 if (qla1280_verbose)
2548 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2551 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2552 mb[0] = MBC_BUS_RESET;
2553 mb[1] = reset_delay;
2554 mb[2] = (uint16_t) bus;
2555 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2558 if (ha->bus_settings[bus].failed_reset_count > 2)
2559 ha->bus_settings[bus].scsi_bus_dead = 1;
2560 ha->bus_settings[bus].failed_reset_count++;
2562 spin_unlock_irq(ha->host->host_lock);
2563 ssleep(reset_delay);
2564 spin_lock_irq(ha->host->host_lock);
2566 ha->bus_settings[bus].scsi_bus_dead = 0;
2567 ha->bus_settings[bus].failed_reset_count = 0;
2568 ha->bus_settings[bus].reset_marker = 0;
2569 /* Issue marker command. */
2570 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2574 * We should probably call qla1280_set_target_parameters()
2575 * here as well for all devices on the bus.
2579 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2581 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2587 * qla1280_device_reset
2588 * Issue bus device reset message to the target.
2591 * ha = adapter block pointer.
2592 * bus = SCSI BUS number.
2599 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2601 uint16_t mb[MAILBOX_REGISTER_COUNT];
2604 ENTER("qla1280_device_reset");
2606 mb[0] = MBC_ABORT_TARGET;
2607 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2609 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2611 /* Issue marker command. */
2612 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2615 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2617 LEAVE("qla1280_device_reset");
2622 * qla1280_abort_command
2623 * Abort command aborts a specified IOCB.
2626 * ha = adapter block pointer.
2627 * sp = SB structure pointer.
2633 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2635 uint16_t mb[MAILBOX_REGISTER_COUNT];
2636 unsigned int bus, target, lun;
2639 ENTER("qla1280_abort_command");
2641 bus = SCSI_BUS_32(sp->cmd);
2642 target = SCSI_TCN_32(sp->cmd);
2643 lun = SCSI_LUN_32(sp->cmd);
2645 sp->flags |= SRB_ABORT_PENDING;
2647 mb[0] = MBC_ABORT_COMMAND;
2648 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2649 mb[2] = handle >> 16;
2650 mb[3] = handle & 0xffff;
2651 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2654 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2655 sp->flags &= ~SRB_ABORT_PENDING;
2659 LEAVE("qla1280_abort_command");
2664 * qla1280_reset_adapter
2668 * ha = adapter block pointer.
2671 qla1280_reset_adapter(struct scsi_qla_host *ha)
2673 struct device_reg __iomem *reg = ha->iobase;
2675 ENTER("qla1280_reset_adapter");
2677 /* Disable ISP chip */
2678 ha->flags.online = 0;
2679 WRT_REG_WORD(®->ictrl, ISP_RESET);
2680 WRT_REG_WORD(®->host_cmd,
2681 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2682 RD_REG_WORD(®->id_l); /* Flush PCI write */
2684 LEAVE("qla1280_reset_adapter");
2688 * Issue marker command.
2689 * Function issues marker IOCB.
2692 * ha = adapter block pointer.
2693 * bus = SCSI BUS number
2696 * type = marker modifier
2699 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2701 struct mrk_entry *pkt;
2703 ENTER("qla1280_marker");
2705 /* Get request packet. */
2706 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2707 pkt->entry_type = MARKER_TYPE;
2708 pkt->lun = (uint8_t) lun;
2709 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2710 pkt->modifier = type;
2711 pkt->entry_status = 0;
2713 /* Issue command to ISP */
2714 qla1280_isp_cmd(ha);
2717 LEAVE("qla1280_marker");
2722 * qla1280_64bit_start_scsi
2723 * The start SCSI is responsible for building request packets on
2724 * request ring and modifying ISP input pointer.
2727 * ha = adapter block pointer.
2728 * sp = SB structure pointer.
2731 * 0 = success, was able to issue command.
2733 #ifdef QLA_64BIT_PTR
2735 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2737 struct device_reg __iomem *reg = ha->iobase;
2738 struct scsi_cmnd *cmd = sp->cmd;
2739 cmd_a64_entry_t *pkt;
2741 dma_addr_t dma_handle;
2748 ENTER("qla1280_64bit_start_scsi:");
2750 /* Calculate number of entries and segments required. */
2752 seg_cnt = scsi_dma_map(cmd);
2755 req_cnt += (seg_cnt - 2) / 5;
2756 if ((seg_cnt - 2) % 5)
2759 } else if (seg_cnt < 0) {
2764 if ((req_cnt + 2) >= ha->req_q_cnt) {
2765 /* Calculate number of free request entries. */
2766 cnt = RD_REG_WORD(®->mailbox4);
2767 if (ha->req_ring_index < cnt)
2768 ha->req_q_cnt = cnt - ha->req_ring_index;
2771 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2774 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2775 ha->req_q_cnt, seg_cnt);
2777 /* If room for request in request ring. */
2778 if ((req_cnt + 2) >= ha->req_q_cnt) {
2779 status = SCSI_MLQUEUE_HOST_BUSY;
2780 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
2781 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2786 /* Check for room in outstanding command list. */
2787 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2788 ha->outstanding_cmds[cnt] != NULL; cnt++);
2790 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2791 status = SCSI_MLQUEUE_HOST_BUSY;
2792 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2793 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2797 ha->outstanding_cmds[cnt] = sp;
2798 ha->req_q_cnt -= req_cnt;
2799 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2801 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2802 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2803 dprintk(2, " bus %i, target %i, lun %i\n",
2804 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2805 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2808 * Build command packet.
2810 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2812 pkt->entry_type = COMMAND_A64_TYPE;
2813 pkt->entry_count = (uint8_t) req_cnt;
2814 pkt->sys_define = (uint8_t) ha->req_ring_index;
2815 pkt->entry_status = 0;
2816 pkt->handle = cpu_to_le32(cnt);
2818 /* Zero out remaining portion of packet. */
2819 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2821 /* Set ISP command timeout. */
2822 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
2824 /* Set device target ID and LUN */
2825 pkt->lun = SCSI_LUN_32(cmd);
2826 pkt->target = SCSI_BUS_32(cmd) ?
2827 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2829 /* Enable simple tag queuing if device supports it. */
2830 if (cmd->device->simple_tags)
2831 pkt->control_flags |= cpu_to_le16(BIT_3);
2833 /* Load SCSI command packet. */
2834 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2835 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
2836 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2838 /* Set transfer direction. */
2839 dir = qla1280_data_direction(cmd);
2840 pkt->control_flags |= cpu_to_le16(dir);
2842 /* Set total data segment count. */
2843 pkt->dseg_count = cpu_to_le16(seg_cnt);
2846 * Load data segments.
2848 if (seg_cnt) { /* If data transfer. */
2849 struct scatterlist *sg, *s;
2850 int remseg = seg_cnt;
2852 sg = scsi_sglist(cmd);
2854 /* Setup packet address segment pointer. */
2855 dword_ptr = (u32 *)&pkt->dseg_0_address;
2857 /* Load command entry data segments. */
2858 for_each_sg(sg, s, seg_cnt, cnt) {
2862 dma_handle = sg_dma_address(s);
2864 cpu_to_le32(lower_32_bits(dma_handle));
2866 cpu_to_le32(upper_32_bits(dma_handle));
2867 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2868 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2869 cpu_to_le32(upper_32_bits(dma_handle)),
2870 cpu_to_le32(lower_32_bits(dma_handle)),
2871 cpu_to_le32(sg_dma_len(sg_next(s))));
2874 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2875 "command packet data - b %i, t %i, l %i \n",
2876 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2878 qla1280_dump_buffer(5, (char *)pkt,
2879 REQUEST_ENTRY_SIZE);
2882 * Build continuation packets.
2884 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2885 "remains\n", seg_cnt);
2887 while (remseg > 0) {
2888 /* Update sg start */
2890 /* Adjust ring index. */
2891 ha->req_ring_index++;
2892 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2893 ha->req_ring_index = 0;
2894 ha->request_ring_ptr =
2897 ha->request_ring_ptr++;
2899 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2901 /* Zero out packet. */
2902 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2904 /* Load packet defaults. */
2905 ((struct cont_a64_entry *) pkt)->entry_type =
2907 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2908 ((struct cont_a64_entry *) pkt)->sys_define =
2909 (uint8_t)ha->req_ring_index;
2910 /* Setup packet address segment pointer. */
2912 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2914 /* Load continuation entry data segments. */
2915 for_each_sg(sg, s, remseg, cnt) {
2918 dma_handle = sg_dma_address(s);
2920 cpu_to_le32(lower_32_bits(dma_handle));
2922 cpu_to_le32(upper_32_bits(dma_handle));
2924 cpu_to_le32(sg_dma_len(s));
2925 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2926 cpu_to_le32(upper_32_bits(dma_handle)),
2927 cpu_to_le32(lower_32_bits(dma_handle)),
2928 cpu_to_le32(sg_dma_len(s)));
2931 dprintk(5, "qla1280_64bit_start_scsi: "
2932 "continuation packet data - b %i, t "
2933 "%i, l %i \n", SCSI_BUS_32(cmd),
2934 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2935 qla1280_dump_buffer(5, (char *)pkt,
2936 REQUEST_ENTRY_SIZE);
2938 } else { /* No data transfer */
2939 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2940 "packet data - b %i, t %i, l %i \n",
2941 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2942 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2944 /* Adjust ring index. */
2945 ha->req_ring_index++;
2946 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2947 ha->req_ring_index = 0;
2948 ha->request_ring_ptr = ha->request_ring;
2950 ha->request_ring_ptr++;
2952 /* Set chip new ring index. */
2954 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
2955 sp->flags |= SRB_SENT;
2957 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
2961 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
2963 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
2967 #else /* !QLA_64BIT_PTR */
2970 * qla1280_32bit_start_scsi
2971 * The start SCSI is responsible for building request packets on
2972 * request ring and modifying ISP input pointer.
2974 * The Qlogic firmware interface allows every queue slot to have a SCSI
2975 * command and up to 4 scatter/gather (SG) entries. If we need more
2976 * than 4 SG entries, then continuation entries are used that can
2977 * hold another 7 entries each. The start routine determines if there
2978 * is eought empty slots then build the combination of requests to
2979 * fulfill the OS request.
2982 * ha = adapter block pointer.
2983 * sp = SCSI Request Block structure pointer.
2986 * 0 = success, was able to issue command.
2989 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2991 struct device_reg __iomem *reg = ha->iobase;
2992 struct scsi_cmnd *cmd = sp->cmd;
2993 struct cmd_entry *pkt;
3001 ENTER("qla1280_32bit_start_scsi");
3003 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3006 /* Calculate number of entries and segments required. */
3008 seg_cnt = scsi_dma_map(cmd);
3011 * if greater than four sg entries then we need to allocate
3012 * continuation entries
3015 req_cnt += (seg_cnt - 4) / 7;
3016 if ((seg_cnt - 4) % 7)
3019 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3020 cmd, seg_cnt, req_cnt);
3021 } else if (seg_cnt < 0) {
3026 if ((req_cnt + 2) >= ha->req_q_cnt) {
3027 /* Calculate number of free request entries. */
3028 cnt = RD_REG_WORD(®->mailbox4);
3029 if (ha->req_ring_index < cnt)
3030 ha->req_q_cnt = cnt - ha->req_ring_index;
3033 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3036 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3037 ha->req_q_cnt, seg_cnt);
3038 /* If room for request in request ring. */
3039 if ((req_cnt + 2) >= ha->req_q_cnt) {
3040 status = SCSI_MLQUEUE_HOST_BUSY;
3041 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3042 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3043 ha->req_q_cnt, req_cnt);
3047 /* Check for empty slot in outstanding command list. */
3048 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3049 ha->outstanding_cmds[cnt]; cnt++);
3051 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3052 status = SCSI_MLQUEUE_HOST_BUSY;
3053 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3054 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3058 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3059 ha->outstanding_cmds[cnt] = sp;
3060 ha->req_q_cnt -= req_cnt;
3063 * Build command packet.
3065 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3067 pkt->entry_type = COMMAND_TYPE;
3068 pkt->entry_count = (uint8_t) req_cnt;
3069 pkt->sys_define = (uint8_t) ha->req_ring_index;
3070 pkt->entry_status = 0;
3071 pkt->handle = cpu_to_le32(cnt);
3073 /* Zero out remaining portion of packet. */
3074 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3076 /* Set ISP command timeout. */
3077 pkt->timeout = cpu_to_le16(scsi_cmd_to_rq(cmd)->timeout / HZ);
3079 /* Set device target ID and LUN */
3080 pkt->lun = SCSI_LUN_32(cmd);
3081 pkt->target = SCSI_BUS_32(cmd) ?
3082 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3084 /* Enable simple tag queuing if device supports it. */
3085 if (cmd->device->simple_tags)
3086 pkt->control_flags |= cpu_to_le16(BIT_3);
3088 /* Load SCSI command packet. */
3089 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3090 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
3092 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3093 /* Set transfer direction. */
3094 dir = qla1280_data_direction(cmd);
3095 pkt->control_flags |= cpu_to_le16(dir);
3097 /* Set total data segment count. */
3098 pkt->dseg_count = cpu_to_le16(seg_cnt);
3101 * Load data segments.
3104 struct scatterlist *sg, *s;
3105 int remseg = seg_cnt;
3107 sg = scsi_sglist(cmd);
3109 /* Setup packet address segment pointer. */
3110 dword_ptr = &pkt->dseg_0_address;
3112 dprintk(3, "Building S/G data segments..\n");
3113 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3115 /* Load command entry data segments. */
3116 for_each_sg(sg, s, seg_cnt, cnt) {
3120 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3121 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3122 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3123 (lower_32_bits(sg_dma_address(s))),
3128 * Build continuation packets.
3130 dprintk(3, "S/G Building Continuation"
3131 "...seg_cnt=0x%x remains\n", seg_cnt);
3132 while (remseg > 0) {
3133 /* Continue from end point */
3135 /* Adjust ring index. */
3136 ha->req_ring_index++;
3137 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3138 ha->req_ring_index = 0;
3139 ha->request_ring_ptr =
3142 ha->request_ring_ptr++;
3144 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3146 /* Zero out packet. */
3147 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3149 /* Load packet defaults. */
3150 ((struct cont_entry *) pkt)->
3151 entry_type = CONTINUE_TYPE;
3152 ((struct cont_entry *) pkt)->entry_count = 1;
3154 ((struct cont_entry *) pkt)->sys_define =
3155 (uint8_t) ha->req_ring_index;
3157 /* Setup packet address segment pointer. */
3159 &((struct cont_entry *) pkt)->dseg_0_address;
3161 /* Load continuation entry data segments. */
3162 for_each_sg(sg, s, remseg, cnt) {
3166 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3168 cpu_to_le32(sg_dma_len(s));
3170 "S/G Segment Cont. phys_addr=0x%x, "
3172 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
3173 cpu_to_le32(sg_dma_len(s)));
3176 dprintk(5, "qla1280_32bit_start_scsi: "
3177 "continuation packet data - "
3178 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3179 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3180 qla1280_dump_buffer(5, (char *)pkt,
3181 REQUEST_ENTRY_SIZE);
3183 } else { /* No data transfer at all */
3184 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3185 "packet data - \n");
3186 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3188 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3189 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3190 REQUEST_ENTRY_SIZE);
3192 /* Adjust ring index. */
3193 ha->req_ring_index++;
3194 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3195 ha->req_ring_index = 0;
3196 ha->request_ring_ptr = ha->request_ring;
3198 ha->request_ring_ptr++;
3200 /* Set chip new ring index. */
3201 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3202 "for pending command\n");
3203 sp->flags |= SRB_SENT;
3205 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3209 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3211 LEAVE("qla1280_32bit_start_scsi");
3219 * Function is responsible for locking ring and
3220 * getting a zeroed out request packet.
3223 * ha = adapter block pointer.
3226 * 0 = failed to get slot.
3229 qla1280_req_pkt(struct scsi_qla_host *ha)
3231 struct device_reg __iomem *reg = ha->iobase;
3232 request_t *pkt = NULL;
3236 ENTER("qla1280_req_pkt");
3239 * This can be called from interrupt context, damn it!!!
3241 /* Wait for 30 seconds for slot. */
3242 for (timer = 15000000; timer; timer--) {
3243 if (ha->req_q_cnt > 0) {
3244 /* Calculate number of free request entries. */
3245 cnt = RD_REG_WORD(®->mailbox4);
3246 if (ha->req_ring_index < cnt)
3247 ha->req_q_cnt = cnt - ha->req_ring_index;
3250 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3253 /* Found empty request ring slot? */
3254 if (ha->req_q_cnt > 0) {
3256 pkt = ha->request_ring_ptr;
3258 /* Zero out packet. */
3259 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3262 * How can this be right when we have a ring
3265 /* Set system defined field. */
3266 pkt->sys_define = (uint8_t) ha->req_ring_index;
3268 /* Set entry count. */
3269 pkt->entry_count = 1;
3276 /* Check for pending interrupts. */
3281 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3283 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3290 * Function is responsible for modifying ISP input pointer.
3291 * Releases ring lock.
3294 * ha = adapter block pointer.
3297 qla1280_isp_cmd(struct scsi_qla_host *ha)
3299 struct device_reg __iomem *reg = ha->iobase;
3301 ENTER("qla1280_isp_cmd");
3303 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3304 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3305 REQUEST_ENTRY_SIZE);
3307 /* Adjust ring index. */
3308 ha->req_ring_index++;
3309 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3310 ha->req_ring_index = 0;
3311 ha->request_ring_ptr = ha->request_ring;
3313 ha->request_ring_ptr++;
3316 * Update request index to mailbox4 (Request Queue In).
3318 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3320 LEAVE("qla1280_isp_cmd");
3323 /****************************************************************************/
3324 /* Interrupt Service Routine. */
3325 /****************************************************************************/
3327 /****************************************************************************
3329 * Calls I/O done on command completion.
3332 * ha = adapter block pointer.
3333 * done_q = done queue.
3334 ****************************************************************************/
3336 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3338 struct device_reg __iomem *reg = ha->iobase;
3339 struct response *pkt;
3340 struct srb *sp = NULL;
3341 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3346 ENTER("qla1280_isr");
3348 istatus = RD_REG_WORD(®->istatus);
3349 if (!(istatus & (RISC_INT | PCI_INT)))
3352 /* Save mailbox register 5 */
3353 mailbox[5] = RD_REG_WORD(®->mailbox5);
3355 /* Check for mailbox interrupt. */
3357 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3359 if (mailbox[0] & BIT_0) {
3360 /* Get mailbox data. */
3361 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3364 *wptr++ = RD_REG_WORD(®->mailbox0);
3365 *wptr++ = RD_REG_WORD(®->mailbox1);
3366 *wptr = RD_REG_WORD(®->mailbox2);
3367 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3369 *wptr++ = RD_REG_WORD(®->mailbox3);
3370 *wptr++ = RD_REG_WORD(®->mailbox4);
3372 *wptr++ = RD_REG_WORD(®->mailbox6);
3373 *wptr = RD_REG_WORD(®->mailbox7);
3376 /* Release mailbox registers. */
3378 WRT_REG_WORD(®->semaphore, 0);
3379 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3381 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3384 /* Handle asynchronous event */
3385 switch (mailbox[0]) {
3386 case MBA_SCSI_COMPLETION: /* Response completion */
3387 dprintk(5, "qla1280_isr: mailbox SCSI response "
3390 if (ha->flags.online) {
3391 /* Get outstanding command index. */
3392 index = mailbox[2] << 16 | mailbox[1];
3394 /* Validate handle. */
3395 if (index < MAX_OUTSTANDING_COMMANDS)
3396 sp = ha->outstanding_cmds[index];
3401 /* Free outstanding command slot. */
3402 ha->outstanding_cmds[index] = NULL;
3404 /* Save ISP completion status */
3405 CMD_RESULT(sp->cmd) = 0;
3406 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3408 /* Place block on done queue */
3409 list_add_tail(&sp->list, done_q);
3412 * If we get here we have a real problem!
3415 "qla1280: ISP invalid handle\n");
3420 case MBA_BUS_RESET: /* SCSI Bus Reset */
3421 ha->flags.reset_marker = 1;
3422 index = mailbox[6] & BIT_0;
3423 ha->bus_settings[index].reset_marker = 1;
3425 printk(KERN_DEBUG "qla1280_isr(): index %i "
3426 "asynchronous BUS_RESET\n", index);
3429 case MBA_SYSTEM_ERR: /* System Error */
3431 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3432 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3436 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3438 "qla1280: ISP Request Transfer Error\n");
3441 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3443 "qla1280: ISP Response Transfer Error\n");
3446 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3447 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3450 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3452 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3455 case MBA_DEVICE_RESET: /* Bus Device Reset */
3456 printk(KERN_INFO "qla1280_isr(): asynchronous "
3457 "BUS_DEVICE_RESET\n");
3459 ha->flags.reset_marker = 1;
3460 index = mailbox[6] & BIT_0;
3461 ha->bus_settings[index].reset_marker = 1;
3464 case MBA_BUS_MODE_CHANGE:
3466 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3470 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3471 if (mailbox[0] < MBA_ASYNC_EVENT) {
3473 memcpy((uint16_t *) ha->mailbox_out, wptr,
3474 MAILBOX_REGISTER_COUNT *
3477 if(ha->mailbox_wait != NULL)
3478 complete(ha->mailbox_wait);
3483 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3487 * We will receive interrupts during mailbox testing prior to
3488 * the card being marked online, hence the double check.
3490 if (!(ha->flags.online && !ha->mailbox_wait)) {
3491 dprintk(2, "qla1280_isr: Response pointer Error\n");
3495 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3498 while (ha->rsp_ring_index != mailbox[5]) {
3499 pkt = ha->response_ring_ptr;
3501 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3502 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3503 dprintk(5,"qla1280_isr: response packet data\n");
3504 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3506 if (pkt->entry_type == STATUS_TYPE) {
3507 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3508 || pkt->comp_status || pkt->entry_status) {
3509 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3510 "0x%x mailbox[5] = 0x%x, comp_status "
3511 "= 0x%x, scsi_status = 0x%x\n",
3512 ha->rsp_ring_index, mailbox[5],
3513 le16_to_cpu(pkt->comp_status),
3514 le16_to_cpu(pkt->scsi_status));
3517 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3518 "0x%x, mailbox[5] = 0x%x\n",
3519 ha->rsp_ring_index, mailbox[5]);
3520 dprintk(2, "qla1280_isr: response packet data\n");
3521 qla1280_dump_buffer(2, (char *)pkt,
3522 RESPONSE_ENTRY_SIZE);
3525 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3526 dprintk(2, "status: Cmd %p, handle %i\n",
3527 ha->outstanding_cmds[pkt->handle]->cmd,
3529 if (pkt->entry_type == STATUS_TYPE)
3530 qla1280_status_entry(ha, pkt, done_q);
3532 qla1280_error_entry(ha, pkt, done_q);
3533 /* Adjust ring index. */
3534 ha->rsp_ring_index++;
3535 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3536 ha->rsp_ring_index = 0;
3537 ha->response_ring_ptr = ha->response_ring;
3539 ha->response_ring_ptr++;
3540 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3545 LEAVE("qla1280_isr");
3550 * Processes asynchronous reset.
3553 * ha = adapter block pointer.
3556 qla1280_rst_aen(struct scsi_qla_host *ha)
3560 ENTER("qla1280_rst_aen");
3562 if (ha->flags.online && !ha->flags.reset_active &&
3563 !ha->flags.abort_isp_active) {
3564 ha->flags.reset_active = 1;
3565 while (ha->flags.reset_marker) {
3566 /* Issue marker command. */
3567 ha->flags.reset_marker = 0;
3568 for (bus = 0; bus < ha->ports &&
3569 !ha->flags.reset_marker; bus++) {
3570 if (ha->bus_settings[bus].reset_marker) {
3571 ha->bus_settings[bus].reset_marker = 0;
3572 qla1280_marker(ha, bus, 0, 0,
3579 LEAVE("qla1280_rst_aen");
3584 * qla1280_status_entry
3585 * Processes received ISP status entry.
3588 * ha = adapter block pointer.
3589 * pkt = entry pointer.
3590 * done_q = done queue.
3593 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3594 struct list_head *done_q)
3598 struct scsi_cmnd *cmd;
3599 uint32_t handle = le32_to_cpu(pkt->handle);
3600 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3601 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3603 ENTER("qla1280_status_entry");
3605 /* Validate handle. */
3606 if (handle < MAX_OUTSTANDING_COMMANDS)
3607 sp = ha->outstanding_cmds[handle];
3612 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3616 /* Free outstanding command slot. */
3617 ha->outstanding_cmds[handle] = NULL;
3621 if (comp_status || scsi_status) {
3622 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3623 "0x%x, handle = 0x%x\n", comp_status,
3624 scsi_status, handle);
3627 /* Target busy or queue full */
3628 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3629 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3630 CMD_RESULT(cmd) = scsi_status & 0xff;
3633 /* Save ISP completion status */
3634 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3636 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3637 if (comp_status != CS_ARS_FAILED) {
3638 uint16_t req_sense_length =
3639 le16_to_cpu(pkt->req_sense_length);
3640 if (req_sense_length < CMD_SNSLEN(cmd))
3641 sense_sz = req_sense_length;
3644 * scsi_cmnd->sense_buffer is
3645 * 64 bytes, why only copy 63?
3646 * This looks wrong! /Jes
3648 sense_sz = CMD_SNSLEN(cmd) - 1;
3650 memcpy(cmd->sense_buffer,
3651 &pkt->req_sense_data, sense_sz);
3654 memset(cmd->sense_buffer + sense_sz, 0,
3655 SCSI_SENSE_BUFFERSIZE - sense_sz);
3657 dprintk(2, "qla1280_status_entry: Check "
3658 "condition Sense data, b %i, t %i, "
3659 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3662 qla1280_dump_buffer(2,
3663 (char *)cmd->sense_buffer,
3668 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3670 /* Place command on done queue. */
3671 list_add_tail(&sp->list, done_q);
3673 LEAVE("qla1280_status_entry");
3677 * qla1280_error_entry
3678 * Processes error entry.
3681 * ha = adapter block pointer.
3682 * pkt = entry pointer.
3683 * done_q = done queue.
3686 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3687 struct list_head *done_q)
3690 uint32_t handle = le32_to_cpu(pkt->handle);
3692 ENTER("qla1280_error_entry");
3694 if (pkt->entry_status & BIT_3)
3695 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3696 else if (pkt->entry_status & BIT_2)
3697 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3698 else if (pkt->entry_status & BIT_1)
3699 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3701 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3703 /* Validate handle. */
3704 if (handle < MAX_OUTSTANDING_COMMANDS)
3705 sp = ha->outstanding_cmds[handle];
3710 /* Free outstanding command slot. */
3711 ha->outstanding_cmds[handle] = NULL;
3713 /* Bad payload or header */
3714 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3715 /* Bad payload or header, set error status. */
3716 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3717 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3718 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3719 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3721 /* Set error status. */
3722 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3725 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3727 /* Place command on done queue. */
3728 list_add_tail(&sp->list, done_q);
3730 #ifdef QLA_64BIT_PTR
3731 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3732 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3736 LEAVE("qla1280_error_entry");
3741 * Resets ISP and aborts all outstanding commands.
3744 * ha = adapter block pointer.
3750 qla1280_abort_isp(struct scsi_qla_host *ha)
3752 struct device_reg __iomem *reg = ha->iobase;
3758 ENTER("qla1280_abort_isp");
3760 if (ha->flags.abort_isp_active || !ha->flags.online)
3763 ha->flags.abort_isp_active = 1;
3765 /* Disable ISP interrupts. */
3766 qla1280_disable_intrs(ha);
3767 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3768 RD_REG_WORD(®->id_l);
3770 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3772 /* Dequeue all commands in outstanding command list. */
3773 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3774 struct scsi_cmnd *cmd;
3775 sp = ha->outstanding_cmds[cnt];
3778 CMD_RESULT(cmd) = DID_RESET << 16;
3779 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
3780 ha->outstanding_cmds[cnt] = NULL;
3781 list_add_tail(&sp->list, &ha->done_q);
3787 status = qla1280_load_firmware(ha);
3791 /* Setup adapter based on NVRAM parameters. */
3792 qla1280_nvram_config (ha);
3794 status = qla1280_init_rings(ha);
3798 /* Issue SCSI reset. */
3799 for (bus = 0; bus < ha->ports; bus++)
3800 qla1280_bus_reset(ha, bus);
3802 ha->flags.abort_isp_active = 0;
3806 "qla1280: ISP error recovery failed, board disabled");
3807 qla1280_reset_adapter(ha);
3808 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3811 LEAVE("qla1280_abort_isp");
3817 * qla1280_debounce_register
3818 * Debounce register.
3821 * port = register address.
3827 qla1280_debounce_register(volatile u16 __iomem * addr)
3832 ret = RD_REG_WORD(addr);
3833 ret2 = RD_REG_WORD(addr);
3840 ret = RD_REG_WORD(addr);
3841 ret2 = RD_REG_WORD(addr);
3842 } while (ret != ret2);
3848 /************************************************************************
3849 * qla1280_check_for_dead_scsi_bus *
3851 * This routine checks for a dead SCSI bus *
3852 ************************************************************************/
3853 #define SET_SXP_BANK 0x0100
3854 #define SCSI_PHASE_INVALID 0x87FF
3856 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3858 uint16_t config_reg, scsi_control;
3859 struct device_reg __iomem *reg = ha->iobase;
3861 if (ha->bus_settings[bus].scsi_bus_dead) {
3862 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3863 config_reg = RD_REG_WORD(®->cfg_1);
3864 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
3865 scsi_control = RD_REG_WORD(®->scsiControlPins);
3866 WRT_REG_WORD(®->cfg_1, config_reg);
3867 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
3869 if (scsi_control == SCSI_PHASE_INVALID) {
3870 ha->bus_settings[bus].scsi_bus_dead = 1;
3871 return 1; /* bus is dead */
3873 ha->bus_settings[bus].scsi_bus_dead = 0;
3874 ha->bus_settings[bus].failed_reset_count = 0;
3877 return 0; /* bus is not dead */
3881 qla1280_get_target_parameters(struct scsi_qla_host *ha,
3882 struct scsi_device *device)
3884 uint16_t mb[MAILBOX_REGISTER_COUNT];
3885 int bus, target, lun;
3887 bus = device->channel;
3888 target = device->id;
3892 mb[0] = MBC_GET_TARGET_PARAMETERS;
3893 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3895 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3898 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3901 printk(KERN_CONT " Sync: period %d, offset %d",
3902 (mb[3] & 0xff), (mb[3] >> 8));
3904 printk(KERN_CONT ", Wide");
3905 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3906 printk(KERN_CONT ", DT");
3908 printk(KERN_CONT " Async");
3910 if (device->simple_tags)
3911 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);
3912 printk(KERN_CONT "\n");
3918 __qla1280_dump_buffer(char *b, int size)
3923 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3924 "Bh Ch Dh Eh Fh\n");
3925 printk(KERN_DEBUG "---------------------------------------------"
3926 "------------------\n");
3928 for (cnt = 0; cnt < size;) {
3931 printk("0x%02x", c);
3942 /**************************************************************************
3943 * ql1280_print_scsi_cmd
3945 **************************************************************************/
3947 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
3949 struct scsi_qla_host *ha;
3950 struct Scsi_Host *host = CMD_HOST(cmd);
3952 /* struct scatterlist *sg; */
3955 ha = (struct scsi_qla_host *)host->hostdata;
3957 sp = scsi_cmd_priv(cmd);
3958 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
3959 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
3960 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
3963 for (i = 0; i < cmd->cmd_len; i++) {
3964 printk("0x%02x ", cmd->cmnd[i]);
3966 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
3967 printk(" request buffer=0x%p, request buffer len=0x%x\n",
3968 scsi_sglist(cmd), scsi_bufflen(cmd));
3971 sg = (struct scatterlist *) cmd->request_buffer;
3972 printk(" SG buffer: \n");
3973 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
3975 printk(" tag=%d, transfersize=0x%x \n",
3976 scsi_cmd_to_rq(cmd)->tag, cmd->transfersize);
3977 printk(" underflow size = 0x%x, direction=0x%x\n",
3978 cmd->underflow, cmd->sc_data_direction);
3981 /**************************************************************************
3982 * ql1280_dump_device
3984 **************************************************************************/
3986 ql1280_dump_device(struct scsi_qla_host *ha)
3989 struct scsi_cmnd *cp;
3993 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
3995 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
3996 if ((sp = ha->outstanding_cmds[i]) == NULL)
3998 if ((cp = sp->cmd) == NULL)
4000 qla1280_print_scsi_cmd(1, cp);
4015 struct setup_tokens {
4020 static struct setup_tokens setup_token[] __initdata =
4022 { "nvram", TOKEN_NVRAM },
4023 { "sync", TOKEN_SYNC },
4024 { "wide", TOKEN_WIDE },
4025 { "ppr", TOKEN_PPR },
4026 { "verbose", TOKEN_VERBOSE },
4027 { "debug", TOKEN_DEBUG },
4031 /**************************************************************************
4034 * Handle boot parameters. This really needs to be changed so one
4035 * can specify per adapter parameters.
4036 **************************************************************************/
4038 qla1280_setup(char *s)
4045 while (cp && (ptr = strchr(cp, ':'))) {
4047 if (!strcmp(ptr, "yes")) {
4050 } else if (!strcmp(ptr, "no")) {
4054 val = simple_strtoul(ptr, &ptr, 0);
4056 switch (qla1280_get_token(cp)) {
4059 driver_setup.no_nvram = 1;
4063 driver_setup.no_sync = 1;
4064 else if (val != 0x10000)
4065 driver_setup.sync_mask = val;
4069 driver_setup.no_wide = 1;
4070 else if (val != 0x10000)
4071 driver_setup.wide_mask = val;
4075 driver_setup.no_ppr = 1;
4076 else if (val != 0x10000)
4077 driver_setup.ppr_mask = val;
4080 qla1280_verbose = val;
4083 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4087 cp = strchr(ptr, ';');
4099 qla1280_get_token(char *str)
4105 sep = strchr(str, ':');
4108 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
4109 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4110 ret = setup_token[i].val;
4120 static const struct scsi_host_template qla1280_driver_template = {
4121 .module = THIS_MODULE,
4122 .proc_name = "qla1280",
4123 .name = "Qlogic ISP 1280/12160",
4124 .info = qla1280_info,
4125 .slave_configure = qla1280_slave_configure,
4126 .queuecommand = qla1280_queuecommand,
4127 .eh_abort_handler = qla1280_eh_abort,
4128 .eh_device_reset_handler= qla1280_eh_device_reset,
4129 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4130 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4131 .bios_param = qla1280_biosparam,
4132 .can_queue = MAX_OUTSTANDING_COMMANDS,
4134 .sg_tablesize = SG_ALL,
4135 .cmd_size = sizeof(struct srb),
4140 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4142 int devnum = id->driver_data;
4143 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4144 struct Scsi_Host *host;
4145 struct scsi_qla_host *ha;
4146 int error = -ENODEV;
4148 /* Bypass all AMI SUBSYS VENDOR IDs */
4149 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4151 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4155 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4156 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4158 if (pci_enable_device(pdev)) {
4160 "qla1280: Failed to enabled pci device, aborting.\n");
4164 pci_set_master(pdev);
4167 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4170 "qla1280: Failed to register host, aborting.\n");
4171 goto error_disable_device;
4174 ha = (struct scsi_qla_host *)host->hostdata;
4175 memset(ha, 0, sizeof(struct scsi_qla_host));
4178 ha->devnum = devnum; /* specifies microcode load address */
4180 #ifdef QLA_64BIT_PTR
4181 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
4182 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4183 printk(KERN_WARNING "scsi(%li): Unable to set a "
4184 "suitable DMA mask - aborting\n", ha->host_no);
4186 goto error_put_host;
4189 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4192 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4193 printk(KERN_WARNING "scsi(%li): Unable to set a "
4194 "suitable DMA mask - aborting\n", ha->host_no);
4196 goto error_put_host;
4200 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
4201 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4202 &ha->request_dma, GFP_KERNEL);
4203 if (!ha->request_ring) {
4204 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4205 goto error_put_host;
4208 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
4209 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4210 &ha->response_dma, GFP_KERNEL);
4211 if (!ha->response_ring) {
4212 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4213 goto error_free_request_ring;
4216 ha->ports = bdp->numPorts;
4219 ha->host_no = host->host_no;
4221 host->irq = pdev->irq;
4222 host->max_channel = bdp->numPorts - 1;
4223 host->max_lun = MAX_LUNS - 1;
4224 host->max_id = MAX_TARGETS;
4225 host->max_sectors = 1024;
4226 host->unique_id = host->host_no;
4230 #if MEMORY_MAPPED_IO
4231 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
4233 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4234 goto error_free_response_ring;
4237 host->base = (unsigned long)ha->mmpbase;
4238 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4240 host->io_port = pci_resource_start(ha->pdev, 0);
4241 if (!request_region(host->io_port, 0xff, "qla1280")) {
4242 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4243 "0x%04lx-0x%04lx - already in use\n",
4244 host->io_port, host->io_port + 0xff);
4245 goto error_free_response_ring;
4248 ha->iobase = (struct device_reg *)host->io_port;
4251 INIT_LIST_HEAD(&ha->done_q);
4253 /* Disable ISP interrupts. */
4254 qla1280_disable_intrs(ha);
4256 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
4258 printk("qla1280 : Failed to reserve interrupt %d already "
4259 "in use\n", pdev->irq);
4260 goto error_release_region;
4263 /* load the F/W, read paramaters, and init the H/W */
4264 if (qla1280_initialize_adapter(ha)) {
4265 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4266 goto error_free_irq;
4269 /* set our host ID (need to do something about our two IDs) */
4270 host->this_id = ha->bus_settings[0].id;
4272 pci_set_drvdata(pdev, host);
4274 error = scsi_add_host(host, &pdev->dev);
4276 goto error_disable_adapter;
4277 scsi_scan_host(host);
4281 error_disable_adapter:
4282 qla1280_disable_intrs(ha);
4284 free_irq(pdev->irq, ha);
4285 error_release_region:
4286 #if MEMORY_MAPPED_IO
4287 iounmap(ha->mmpbase);
4289 release_region(host->io_port, 0xff);
4291 error_free_response_ring:
4292 dma_free_coherent(&ha->pdev->dev,
4293 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4294 ha->response_ring, ha->response_dma);
4295 error_free_request_ring:
4296 dma_free_coherent(&ha->pdev->dev,
4297 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4298 ha->request_ring, ha->request_dma);
4300 scsi_host_put(host);
4301 error_disable_device:
4302 pci_disable_device(pdev);
4309 qla1280_remove_one(struct pci_dev *pdev)
4311 struct Scsi_Host *host = pci_get_drvdata(pdev);
4312 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4314 scsi_remove_host(host);
4316 qla1280_disable_intrs(ha);
4318 free_irq(pdev->irq, ha);
4320 #if MEMORY_MAPPED_IO
4321 iounmap(ha->mmpbase);
4323 release_region(host->io_port, 0xff);
4326 dma_free_coherent(&ha->pdev->dev,
4327 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4328 ha->request_ring, ha->request_dma);
4329 dma_free_coherent(&ha->pdev->dev,
4330 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4331 ha->response_ring, ha->response_dma);
4333 pci_disable_device(pdev);
4335 scsi_host_put(host);
4338 static struct pci_driver qla1280_pci_driver = {
4340 .id_table = qla1280_pci_tbl,
4341 .probe = qla1280_probe_one,
4342 .remove = qla1280_remove_one,
4350 * If we are called as a module, the qla1280 pointer may not be null
4351 * and it would point to our bootup string, just like on the lilo
4352 * command line. IF not NULL, then process this config string with
4356 * To add options at boot time add a line to your lilo.conf file like:
4357 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4358 * which will result in the first four devices on the first two
4359 * controllers being set to a tagged queue depth of 32.
4362 qla1280_setup(qla1280);
4365 return pci_register_driver(&qla1280_pci_driver);
4373 pci_unregister_driver(&qla1280_pci_driver);
4374 /* release any allocated firmware images */
4375 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4376 release_firmware(qla1280_fw_tbl[i].fw);
4377 qla1280_fw_tbl[i].fw = NULL;
4381 module_init(qla1280_init);
4382 module_exit(qla1280_exit);
4384 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4385 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4386 MODULE_LICENSE("GPL");
4387 MODULE_FIRMWARE("qlogic/1040.bin");
4388 MODULE_FIRMWARE("qlogic/1280.bin");
4389 MODULE_FIRMWARE("qlogic/12160.bin");
4390 MODULE_VERSION(QLA1280_VERSION);