1 // SPDX-License-Identifier: GPL-2.0-or-later
2 /******************************************************************************
3 * QLOGIC LINUX SOFTWARE
5 * QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver
6 * Copyright (C) 2000 Qlogic Corporation (www.qlogic.com)
7 * Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc.
8 * Copyright (C) 2003-2004 Christoph Hellwig
10 ******************************************************************************/
11 #define QLA1280_VERSION "3.27.1"
12 /*****************************************************************************
14 Rev 3.27.1, February 8, 2010, Michael Reed
15 - Retain firmware image for error recovery.
16 Rev 3.27, February 10, 2009, Michael Reed
17 - General code cleanup.
18 - Improve error recovery.
19 Rev 3.26, January 16, 2006 Jes Sorensen
20 - Ditch all < 2.6 support
21 Rev 3.25.1, February 10, 2005 Christoph Hellwig
22 - use pci_map_single to map non-S/G requests
23 - remove qla1280_proc_info
24 Rev 3.25, September 28, 2004, Christoph Hellwig
25 - add support for ISP1020/1040
26 - don't include "scsi.h" anymore for 2.6.x
27 Rev 3.24.4 June 7, 2004 Christoph Hellwig
28 - restructure firmware loading, cleanup initialization code
29 - prepare support for ISP1020/1040 chips
30 Rev 3.24.3 January 19, 2004, Jes Sorensen
31 - Handle PCI DMA mask settings correctly
32 - Correct order of error handling in probe_one, free_irq should not
33 be called if request_irq failed
34 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
35 - Big endian fixes (James)
36 - Remove bogus IOCB content on zero data transfer commands (Andrew)
37 Rev 3.24.1 January 5, 2004, Jes Sorensen
38 - Initialize completion queue to avoid OOPS on probe
39 - Handle interrupts during mailbox testing
40 Rev 3.24 November 17, 2003, Christoph Hellwig
41 - use struct list_head for completion queue
42 - avoid old Scsi_FOO typedefs
43 - cleanup 2.4 compat glue a bit
44 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
45 - make initialization for memory mapped vs port I/O more similar
46 - remove broken pci config space manipulation
48 - this is an almost perfect 2.6 scsi driver now! ;)
49 Rev 3.23.39 December 17, 2003, Jes Sorensen
50 - Delete completion queue from srb if mailbox command failed to
51 to avoid qla1280_done completeting qla1280_error_action's
53 - Reduce arguments for qla1280_done
54 Rev 3.23.38 October 18, 2003, Christoph Hellwig
55 - Convert to new-style hotplugable driver for 2.6
56 - Fix missing scsi_unregister/scsi_host_put on HBA removal
57 - Kill some more cruft
58 Rev 3.23.37 October 1, 2003, Jes Sorensen
59 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
61 - Clean up locking in probe path
62 Rev 3.23.36 October 1, 2003, Christoph Hellwig
63 - queuecommand only ever receives new commands - clear flags
64 - Reintegrate lost fixes from Linux 2.5
65 Rev 3.23.35 August 14, 2003, Jes Sorensen
67 Rev 3.23.34 July 23, 2003, Jes Sorensen
68 - Remove pointless TRUE/FALSE macros
69 - Clean up vchan handling
70 Rev 3.23.33 July 3, 2003, Jes Sorensen
71 - Don't define register access macros before define determining MMIO.
72 This just happened to work out on ia64 but not elsewhere.
73 - Don't try and read from the card while it is in reset as
74 it won't respond and causes an MCA
75 Rev 3.23.32 June 23, 2003, Jes Sorensen
76 - Basic support for boot time arguments
77 Rev 3.23.31 June 8, 2003, Jes Sorensen
78 - Reduce boot time messages
79 Rev 3.23.30 June 6, 2003, Jes Sorensen
80 - Do not enable sync/wide/ppr before it has been determined
81 that the target device actually supports it
82 - Enable DMA arbitration for multi channel controllers
83 Rev 3.23.29 June 3, 2003, Jes Sorensen
85 Rev 3.23.28 June 3, 2003, Jes Sorensen
86 - Eliminate duplicate marker commands on bus resets
87 - Handle outstanding commands appropriately on bus/device resets
88 Rev 3.23.27 May 28, 2003, Jes Sorensen
89 - Remove bogus input queue code, let the Linux SCSI layer do the work
90 - Clean up NVRAM handling, only read it once from the card
91 - Add a number of missing default nvram parameters
92 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
93 - Use completion queue for mailbox commands instead of busy wait
94 Rev 3.23.25 Beta May 27, 2003, James Bottomley
95 - Migrate to use new error handling code
96 Rev 3.23.24 Beta May 21, 2003, James Bottomley
98 - Cleanup data direction code
99 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
100 - Switch to using MMIO instead of PIO
101 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
102 - Fix PCI parity problem with 12160 during reset.
103 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
104 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
105 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
106 - Remove < 2.4.x support
107 - Introduce HOST_LOCK to make the spin lock changes portable.
108 - Remove a bunch of idiotic and unnecessary typedef's
109 - Kill all leftovers of target-mode support which never worked anyway
110 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
111 - Do qla1280_pci_config() before calling request_irq() and
113 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
115 - Hand correct arguments to free_irq() in case of failure
116 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
117 - Run source through Lindent and clean up the output
118 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
119 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
120 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
121 - Rely on mailbox commands generating interrupts - do not
122 run qla1280_isr() from ql1280_mailbox_command()
123 - Remove device_reg_t
124 - Integrate ql12160_set_target_parameters() with 1280 version
125 - Make qla1280_setup() non static
126 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
127 sent to the card - this command pauses the firmware!!!
128 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
129 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
130 - Remove a pile of pointless and confusing (srb_t **) and
131 (scsi_lu_t *) typecasts
132 - Explicit mark that we do not use the new error handling (for now)
133 - Remove scsi_qla_host_t and use 'struct' instead
134 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
135 pci_64bit_slot flags which weren't used for anything anyway
136 - Grab host->host_lock while calling qla1280_isr() from abort()
137 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
138 do not need to save/restore flags in the interrupt handler
139 - Enable interrupts early (before any mailbox access) in preparation
140 for cleaning up the mailbox handling
141 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
142 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
143 it with proper use of dprintk().
144 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
145 a debug level argument to determine if data is to be printed
146 - Add KERN_* info to printk()
147 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
148 - Significant cosmetic cleanups
149 - Change debug code to use dprintk() and remove #if mess
150 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
151 - More cosmetic cleanups, fix places treating return as function
152 - use cpu_relax() in qla1280_debounce_register()
153 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
154 - Make it compile under 2.5.5
155 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
156 - Do no typecast short * to long * in QL1280BoardTbl, this
157 broke miserably on big endian boxes
158 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
159 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
160 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
161 unsigned int to match the types from struct scsi_cmnd
162 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
163 - Remove bogus timer_t typedef from qla1280.h
164 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
165 for PCI_ values, call pci_set_master()
166 - Fix memleak of qla1280_buffer on module unload
167 - Only compile module parsing code #ifdef MODULE - should be
168 changed to use individual MODULE_PARM's later
169 - Remove dummy_buffer that was never modified nor printed
170 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
171 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
172 - Remove \r from print statements, this is Linux, not DOS
173 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
175 - Remove C++ compile hack in header file as Linux driver are not
176 supposed to be compiled as C++
177 - Kill MS_64BITS macro as it makes the code more readable
178 - Remove unnecessary flags.in_interrupts bit
179 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
180 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
181 - Check whether the interrupt was generated by the QLA1280 before
183 - qla1280_status_entry(): Only zero out part of sense_buffer that
184 is not being copied into
185 - Remove more superflouous typecasts
186 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
187 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
188 - Don't walk the entire list in qla1280_putq_t() just to directly
189 grab the pointer to the last element afterwards
190 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
191 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
192 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
193 - Set dev->max_sectors to 1024
194 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
195 - Provide compat macros for pci_enable_device(), pci_find_subsys()
196 and scsi_set_pci_device()
197 - Call scsi_set_pci_device() for all devices
198 - Reduce size of kernel version dependent device probe code
199 - Move duplicate probe/init code to separate function
200 - Handle error if qla1280_mem_alloc() fails
201 - Kill OFFSET() macro and use Linux's PCI definitions instead
202 - Kill private structure defining PCI config space (struct config_reg)
203 - Only allocate I/O port region if not in MMIO mode
204 - Remove duplicate (unused) sanity check of sife of srb_t
205 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
206 - Change home-brew memset() implementations to use memset()
207 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
208 port directly is not legal under Linux.
209 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
210 - Remove pre 2.2 kernel support
211 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
212 - Fix MMIO access to use readl/writel instead of directly
213 dereferencing pointers
214 - Nuke MSDOS debugging code
215 - Change true/false data types to int from uint8_t
216 - Use int for counters instead of uint8_t etc.
217 - Clean up size & byte order conversion macro usage
218 Rev 3.23 Beta January 11, 2001 BN Qlogic
219 - Added check of device_id when handling non
220 QLA12160s during detect().
221 Rev 3.22 Beta January 5, 2001 BN Qlogic
222 - Changed queue_task() to schedule_task()
223 for kernels 2.4.0 and higher.
224 Note: 2.4.0-testxx kernels released prior to
225 the actual 2.4.0 kernel release on January 2001
226 will get compile/link errors with schedule_task().
227 Please update your kernel to released 2.4.0 level,
228 or comment lines in this file flagged with 3.22
229 to resolve compile/link error of schedule_task().
230 - Added -DCONFIG_SMP in addition to -D__SMP__
231 in Makefile for 2.4.0 builds of driver as module.
232 Rev 3.21 Beta January 4, 2001 BN Qlogic
233 - Changed criteria of 64/32 Bit mode of HBA
234 operation according to BITS_PER_LONG rather
235 than HBA's NVRAM setting of >4Gig memory bit;
236 so that the HBA auto-configures without the need
237 to setup each system individually.
238 Rev 3.20 Beta December 5, 2000 BN Qlogic
239 - Added priority handling to IA-64 onboard SCSI
240 ISP12160 chip for kernels greater than 2.3.18.
241 - Added irqrestore for qla1280_intr_handler.
242 - Enabled /proc/scsi/qla1280 interface.
243 - Clear /proc/scsi/qla1280 counters in detect().
244 Rev 3.19 Beta October 13, 2000 BN Qlogic
245 - Declare driver_template for new kernel
246 (2.4.0 and greater) scsi initialization scheme.
247 - Update /proc/scsi entry for 2.3.18 kernels and
249 Rev 3.18 Beta October 10, 2000 BN Qlogic
250 - Changed scan order of adapters to map
251 the QLA12160 followed by the QLA1280.
252 Rev 3.17 Beta September 18, 2000 BN Qlogic
253 - Removed warnings for 32 bit 2.4.x compiles
254 - Corrected declared size for request and response
255 DMA addresses that are kept in each ha
256 Rev. 3.16 Beta August 25, 2000 BN Qlogic
257 - Corrected 64 bit addressing issue on IA-64
258 where the upper 32 bits were not properly
259 passed to the RISC engine.
260 Rev. 3.15 Beta August 22, 2000 BN Qlogic
261 - Modified qla1280_setup_chip to properly load
262 ISP firmware for greater that 4 Gig memory on IA-64
263 Rev. 3.14 Beta August 16, 2000 BN Qlogic
264 - Added setting of dma_mask to full 64 bit
265 if flags.enable_64bit_addressing is set in NVRAM
266 Rev. 3.13 Beta August 16, 2000 BN Qlogic
267 - Use new PCI DMA mapping APIs for 2.4.x kernel
268 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
269 - Added check of pci_enable_device to detect() for 2.3.x
270 - Use pci_resource_start() instead of
271 pdev->resource[0].start in detect() for 2.3.x
272 - Updated driver version
273 Rev. 3.11 July 14, 2000 BN Qlogic
274 - Updated SCSI Firmware to following versions:
277 - Updated driver version to 3.11
278 Rev. 3.10 June 23, 2000 BN Qlogic
279 - Added filtering of AMI SubSys Vendor ID devices
281 - DEBUG_QLA1280 undefined and new version BN Qlogic
282 Rev. 3.08b May 9, 2000 MD Dell
283 - Added logic to check against AMI subsystem vendor ID
284 Rev. 3.08 May 4, 2000 DG Qlogic
285 - Added logic to check for PCI subsystem ID.
286 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
287 - Updated SCSI Firmware to following versions:
290 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
291 - Internal revision; not released
292 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
293 - Edit correction for virt_to_bus and PROC.
294 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
295 - Merge changes from ia64 port.
296 Rev. 3.03 Mar 28, 2000 BN Qlogic
297 - Increase version to reflect new code drop with compile fix
298 of issue with inclusion of linux/spinlock for 2.3 kernels
299 Rev. 3.02 Mar 15, 2000 BN Qlogic
300 - Merge qla1280_proc_info from 2.10 code base
301 Rev. 3.01 Feb 10, 2000 BN Qlogic
302 - Corrected code to compile on a 2.2.x kernel.
303 Rev. 3.00 Jan 17, 2000 DG Qlogic
304 - Added 64-bit support.
305 Rev. 2.07 Nov 9, 1999 DG Qlogic
306 - Added new routine to set target parameters for ISP12160.
307 Rev. 2.06 Sept 10, 1999 DG Qlogic
308 - Added support for ISP12160 Ultra 3 chip.
309 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
310 - Modified code to remove errors generated when compiling with
311 Cygnus IA64 Compiler.
312 - Changed conversion of pointers to unsigned longs instead of integers.
313 - Changed type of I/O port variables from uint32_t to unsigned long.
314 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
315 - Changed sprintf and printk format specifiers for pointers to %p.
316 - Changed some int to long type casts where needed in sprintf & printk.
317 - Added l modifiers to sprintf and printk format specifiers for longs.
318 - Removed unused local variables.
319 Rev. 1.20 June 8, 1999 DG, Qlogic
320 Changes to support RedHat release 6.0 (kernel 2.2.5).
321 - Added SCSI exclusive access lock (io_request_lock) when accessing
323 - Added changes for the new LINUX interface template. Some new error
324 handling routines have been added to the template, but for now we
325 will use the old ones.
326 - Initial Beta Release.
327 *****************************************************************************/
330 #include <linux/module.h>
332 #include <linux/types.h>
333 #include <linux/string.h>
334 #include <linux/errno.h>
335 #include <linux/kernel.h>
336 #include <linux/ioport.h>
337 #include <linux/delay.h>
338 #include <linux/timer.h>
339 #include <linux/pci.h>
340 #include <linux/proc_fs.h>
341 #include <linux/stat.h>
342 #include <linux/pci_ids.h>
343 #include <linux/interrupt.h>
344 #include <linux/init.h>
345 #include <linux/dma-mapping.h>
346 #include <linux/firmware.h>
350 #include <asm/byteorder.h>
351 #include <asm/processor.h>
352 #include <asm/types.h>
354 #include <scsi/scsi.h>
355 #include <scsi/scsi_cmnd.h>
356 #include <scsi/scsi_device.h>
357 #include <scsi/scsi_host.h>
358 #include <scsi/scsi_tcq.h>
362 * Compile time Options:
363 * 0 - Disable and 1 - Enable
365 #define DEBUG_QLA1280_INTR 0
366 #define DEBUG_PRINT_NVRAM 0
367 #define DEBUG_QLA1280 0
369 #define MEMORY_MAPPED_IO 1
373 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
374 #define QLA_64BIT_PTR 1
377 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */
379 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
380 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
381 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
382 #define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
383 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
386 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
387 static void qla1280_remove_one(struct pci_dev *);
390 * QLogic Driver Support Function Prototypes.
392 static void qla1280_done(struct scsi_qla_host *);
393 static int qla1280_get_token(char *);
394 static int qla1280_setup(char *s) __init;
397 * QLogic ISP1280 Hardware Support Function Prototypes.
399 static int qla1280_load_firmware(struct scsi_qla_host *);
400 static int qla1280_init_rings(struct scsi_qla_host *);
401 static int qla1280_nvram_config(struct scsi_qla_host *);
402 static int qla1280_mailbox_command(struct scsi_qla_host *,
403 uint8_t, uint16_t *);
404 static int qla1280_bus_reset(struct scsi_qla_host *, int);
405 static int qla1280_device_reset(struct scsi_qla_host *, int, int);
406 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
407 static int qla1280_abort_isp(struct scsi_qla_host *);
409 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
411 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
413 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
414 static void qla1280_poll(struct scsi_qla_host *);
415 static void qla1280_reset_adapter(struct scsi_qla_host *);
416 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
417 static void qla1280_isp_cmd(struct scsi_qla_host *);
418 static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
419 static void qla1280_rst_aen(struct scsi_qla_host *);
420 static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
422 static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
424 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
425 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
426 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
427 static request_t *qla1280_req_pkt(struct scsi_qla_host *);
428 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
430 static void qla1280_get_target_parameters(struct scsi_qla_host *,
431 struct scsi_device *);
432 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
435 static struct qla_driver_setup driver_setup;
438 * convert scsi data direction to request_t control flags
440 static inline uint16_t
441 qla1280_data_direction(struct scsi_cmnd *cmnd)
443 switch(cmnd->sc_data_direction) {
444 case DMA_FROM_DEVICE:
448 case DMA_BIDIRECTIONAL:
449 return BIT_5 | BIT_6;
451 * We could BUG() on default here if one of the four cases aren't
452 * met, but then again if we receive something like that from the
453 * SCSI layer we have more serious problems. This shuts up GCC.
462 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
463 static void __qla1280_dump_buffer(char *, int);
468 * insmod needs to find the variable and make it point to something
471 static char *qla1280;
473 /* insmod qla1280 options=verbose" */
474 module_param(qla1280, charp, 0);
476 __setup("qla1280=", qla1280_setup);
481 * We use the scsi_pointer structure that's included with each scsi_command
482 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
483 * bigger than a scsi_pointer.
486 #define CMD_SP(Cmnd) &Cmnd->SCp
487 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
488 #define CMD_CDBP(Cmnd) Cmnd->cmnd
489 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
490 #define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
491 #define CMD_RESULT(Cmnd) Cmnd->result
492 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
493 #define CMD_REQUEST(Cmnd) Cmnd->request->cmd
495 #define CMD_HOST(Cmnd) Cmnd->device->host
496 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
497 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
498 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
501 /*****************************************/
502 /* ISP Boards supported by this driver */
503 /*****************************************/
506 char *name; /* Board ID String */
507 int numPorts; /* Number of SCSI ports */
508 int fw_index; /* index into qla1280_fw_tbl for firmware */
511 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
512 static struct pci_device_id qla1280_pci_tbl[] = {
513 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
514 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
515 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
516 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
517 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
518 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
519 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
520 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
521 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
522 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
523 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
524 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
527 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
529 static DEFINE_MUTEX(qla1280_firmware_mutex);
533 const struct firmware *fw;
536 #define QL_NUM_FW_IMAGES 3
538 static struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
539 {"qlogic/1040.bin", NULL}, /* image 0 */
540 {"qlogic/1280.bin", NULL}, /* image 1 */
541 {"qlogic/12160.bin", NULL}, /* image 2 */
544 /* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
545 static struct qla_boards ql1280_board_tbl[] = {
546 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
547 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
548 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
549 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
550 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
551 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
552 {.name = " ", .numPorts = 0, .fw_index = -1},
555 static int qla1280_verbose = 1;
558 static int ql_debug_level = 1;
559 #define dprintk(level, format, a...) \
560 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
561 #define qla1280_dump_buffer(level, buf, size) \
562 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
563 #define qla1280_print_scsi_cmd(level, cmd) \
564 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
566 #define ql_debug_level 0
567 #define dprintk(level, format, a...) do{}while(0)
568 #define qla1280_dump_buffer(a, b, c) do{}while(0)
569 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
572 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
573 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
574 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
575 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
578 static int qla1280_read_nvram(struct scsi_qla_host *ha)
585 ENTER("qla1280_read_nvram");
587 if (driver_setup.no_nvram)
590 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
592 wptr = (uint16_t *)&ha->nvram;
595 for (cnt = 0; cnt < 3; cnt++) {
596 *wptr = qla1280_get_nvram_word(ha, cnt);
597 chksum += *wptr & 0xff;
598 chksum += (*wptr >> 8) & 0xff;
602 if (nv->id0 != 'I' || nv->id1 != 'S' ||
603 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
604 dprintk(2, "Invalid nvram ID or version!\n");
607 for (; cnt < sizeof(struct nvram); cnt++) {
608 *wptr = qla1280_get_nvram_word(ha, cnt);
609 chksum += *wptr & 0xff;
610 chksum += (*wptr >> 8) & 0xff;
615 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
616 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
621 if (!driver_setup.no_nvram)
622 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
623 "validate NVRAM checksum, using default "
624 "settings\n", ha->host_no);
629 /* The firmware interface is, um, interesting, in that the
630 * actual firmware image on the chip is little endian, thus,
631 * the process of taking that image to the CPU would end up
632 * little endian. However, the firmware interface requires it
633 * to be read a word (two bytes) at a time.
635 * The net result of this would be that the word (and
636 * doubleword) quantites in the firmware would be correct, but
637 * the bytes would be pairwise reversed. Since most of the
638 * firmware quantites are, in fact, bytes, we do an extra
639 * le16_to_cpu() in the firmware read routine.
641 * The upshot of all this is that the bytes in the firmware
642 * are in the correct places, but the 16 and 32 bit quantites
643 * are still in little endian format. We fix that up below by
644 * doing extra reverses on them */
645 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
646 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
647 for(i = 0; i < MAX_BUSES; i++) {
648 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
649 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
651 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
652 LEAVE("qla1280_read_nvram");
657 /**************************************************************************
659 * Return a string describing the driver.
660 **************************************************************************/
662 qla1280_info(struct Scsi_Host *host)
664 static char qla1280_scsi_name_buffer[125];
666 struct scsi_qla_host *ha;
667 struct qla_boards *bdp;
669 bp = &qla1280_scsi_name_buffer[0];
670 ha = (struct scsi_qla_host *)host->hostdata;
671 bdp = &ql1280_board_tbl[ha->devnum];
672 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
675 "QLogic %s PCI to SCSI Host Adapter\n"
676 " Firmware version: %2d.%02d.%02d, Driver version %s",
677 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
682 /**************************************************************************
683 * qla1280_queuecommand
684 * Queue a command to the controller.
687 * The mid-level driver tries to ensures that queuecommand never gets invoked
688 * concurrently with itself or the interrupt handler (although the
689 * interrupt handler may call this routine as part of request-completion
690 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
691 * context which is a big NO! NO!.
692 **************************************************************************/
694 qla1280_queuecommand_lck(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
696 struct Scsi_Host *host = cmd->device->host;
697 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
698 struct srb *sp = (struct srb *)CMD_SP(cmd);
705 CMD_HANDLE(cmd) = (unsigned char *)NULL;
707 qla1280_print_scsi_cmd(5, cmd);
711 * Using 64 bit commands if the PCI bridge doesn't support it is a
712 * bit wasteful, however this should really only happen if one's
713 * PCI controller is completely broken, like the BCM1250. For
714 * sane hardware this is not an issue.
716 status = qla1280_64bit_start_scsi(ha, sp);
718 status = qla1280_32bit_start_scsi(ha, sp);
723 static DEF_SCSI_QCMD(qla1280_queuecommand)
733 static void qla1280_mailbox_timeout(struct timer_list *t)
735 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
736 struct device_reg __iomem *reg;
739 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
740 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
741 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
742 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
743 complete(ha->mailbox_wait);
747 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
748 struct completion *wait)
751 struct scsi_cmnd *cmd = sp->cmd;
753 spin_unlock_irq(ha->host->host_lock);
754 wait_for_completion_timeout(wait, 4*HZ);
755 spin_lock_irq(ha->host->host_lock);
757 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
759 (*cmd->scsi_done)(cmd);
765 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
767 DECLARE_COMPLETION_ONSTACK(wait);
770 return _qla1280_wait_for_single_command(ha, sp, &wait);
774 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
779 struct scsi_cmnd *cmd;
784 * Wait for all commands with the designated bus/target
785 * to be completed by the firmware
787 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
788 sp = ha->outstanding_cmds[cnt];
792 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
794 if (target >= 0 && SCSI_TCN_32(cmd) != target)
797 status = qla1280_wait_for_single_command(ha, sp);
798 if (status == FAILED)
805 /**************************************************************************
806 * qla1280_error_action
807 * The function will attempt to perform a specified error action and
808 * wait for the results (or time out).
811 * cmd = Linux SCSI command packet of the command that cause the
813 * action = error action to take (see action_t)
818 **************************************************************************/
820 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
822 struct scsi_qla_host *ha;
823 int bus, target, lun;
828 int wait_for_target = -1;
829 DECLARE_COMPLETION_ONSTACK(wait);
831 ENTER("qla1280_error_action");
833 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
834 sp = (struct srb *)CMD_SP(cmd);
835 bus = SCSI_BUS_32(cmd);
836 target = SCSI_TCN_32(cmd);
837 lun = SCSI_LUN_32(cmd);
839 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
840 RD_REG_WORD(&ha->iobase->istatus));
842 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
843 RD_REG_WORD(&ha->iobase->host_cmd),
844 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
847 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
848 "Handle=0x%p, action=0x%x\n",
849 ha->host_no, cmd, CMD_HANDLE(cmd), action);
852 * Check to see if we have the command in the outstanding_cmds[]
853 * array. If not then it must have completed before this error
854 * action was initiated. If the error_action isn't ABORT_COMMAND
855 * then the driver must proceed with the requested action.
858 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
859 if (sp == ha->outstanding_cmds[i]) {
861 sp->wait = &wait; /* we'll wait for it to complete */
866 if (found < 0) { /* driver doesn't have command */
868 if (qla1280_verbose) {
870 "scsi(%ld:%d:%d:%d): specified command has "
871 "already completed.\n", ha->host_no, bus,
879 dprintk(1, "qla1280: RISC aborting command\n");
881 * The abort might fail due to race when the host_lock
882 * is released to issue the abort. As such, we
883 * don't bother to check the return status.
886 qla1280_abort_command(ha, sp, found);
892 "scsi(%ld:%d:%d:%d): Queueing device reset "
893 "command.\n", ha->host_no, bus, target, lun);
894 if (qla1280_device_reset(ha, bus, target) == 0) {
895 /* issued device reset, set wait conditions */
897 wait_for_target = target;
903 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
904 "reset.\n", ha->host_no, bus);
905 if (qla1280_bus_reset(ha, bus) == 0) {
906 /* issued bus reset, set wait conditions */
913 if (qla1280_verbose) {
915 "scsi(%ld): Issued ADAPTER RESET\n",
917 printk(KERN_INFO "scsi(%ld): I/O processing will "
918 "continue automatically\n", ha->host_no);
920 ha->flags.reset_active = 1;
922 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
926 ha->flags.reset_active = 0;
930 * At this point, the host_lock has been released and retaken
931 * by the issuance of the mailbox command.
932 * Wait for the command passed in by the mid-layer if it
933 * was found by the driver. It might have been returned
934 * between eh recovery steps, hence the check of the "found"
939 result = _qla1280_wait_for_single_command(ha, sp, &wait);
941 if (action == ABORT_COMMAND && result != SUCCESS) {
943 "scsi(%li:%i:%i:%i): "
944 "Unable to abort command!\n",
945 ha->host_no, bus, target, lun);
949 * If the command passed in by the mid-layer has been
950 * returned by the board, then wait for any additional
951 * commands which are supposed to complete based upon
954 * All commands are unconditionally returned during a
955 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
958 if (result == SUCCESS && wait_for_bus >= 0) {
959 result = qla1280_wait_for_pending_commands(ha,
960 wait_for_bus, wait_for_target);
963 dprintk(1, "RESET returning %d\n", result);
965 LEAVE("qla1280_error_action");
969 /**************************************************************************
971 * Abort the specified SCSI command(s).
972 **************************************************************************/
974 qla1280_eh_abort(struct scsi_cmnd * cmd)
978 spin_lock_irq(cmd->device->host->host_lock);
979 rc = qla1280_error_action(cmd, ABORT_COMMAND);
980 spin_unlock_irq(cmd->device->host->host_lock);
985 /**************************************************************************
986 * qla1280_device_reset
987 * Reset the specified SCSI device
988 **************************************************************************/
990 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
994 spin_lock_irq(cmd->device->host->host_lock);
995 rc = qla1280_error_action(cmd, DEVICE_RESET);
996 spin_unlock_irq(cmd->device->host->host_lock);
1001 /**************************************************************************
1003 * Reset the specified bus.
1004 **************************************************************************/
1006 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1010 spin_lock_irq(cmd->device->host->host_lock);
1011 rc = qla1280_error_action(cmd, BUS_RESET);
1012 spin_unlock_irq(cmd->device->host->host_lock);
1017 /**************************************************************************
1018 * qla1280_adapter_reset
1019 * Reset the specified adapter (both channels)
1020 **************************************************************************/
1022 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1026 spin_lock_irq(cmd->device->host->host_lock);
1027 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1028 spin_unlock_irq(cmd->device->host->host_lock);
1034 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1035 sector_t capacity, int geom[])
1037 int heads, sectors, cylinders;
1041 cylinders = (unsigned long)capacity / (heads * sectors);
1042 if (cylinders > 1024) {
1045 cylinders = (unsigned long)capacity / (heads * sectors);
1046 /* if (cylinders > 1023)
1047 cylinders = 1023; */
1052 geom[2] = cylinders;
1058 /* disable risc and host interrupts */
1060 qla1280_disable_intrs(struct scsi_qla_host *ha)
1062 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1063 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1066 /* enable risc and host interrupts */
1068 qla1280_enable_intrs(struct scsi_qla_host *ha)
1070 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1071 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1074 /**************************************************************************
1075 * qla1280_intr_handler
1076 * Handles the H/W interrupt
1077 **************************************************************************/
1079 qla1280_intr_handler(int irq, void *dev_id)
1081 struct scsi_qla_host *ha;
1082 struct device_reg __iomem *reg;
1086 ENTER_INTR ("qla1280_intr_handler");
1087 ha = (struct scsi_qla_host *)dev_id;
1089 spin_lock(ha->host->host_lock);
1094 qla1280_disable_intrs(ha);
1096 data = qla1280_debounce_register(®->istatus);
1097 /* Check for pending interrupts. */
1098 if (data & RISC_INT) {
1099 qla1280_isr(ha, &ha->done_q);
1102 if (!list_empty(&ha->done_q))
1105 spin_unlock(ha->host->host_lock);
1107 qla1280_enable_intrs(ha);
1109 LEAVE_INTR("qla1280_intr_handler");
1110 return IRQ_RETVAL(handled);
1115 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1118 uint16_t mb[MAILBOX_REGISTER_COUNT];
1124 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1126 /* Set Target Parameters. */
1127 mb[0] = MBC_SET_TARGET_PARAMETERS;
1128 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1129 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1130 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1131 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1132 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1133 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1134 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1135 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1136 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1138 if (IS_ISP1x160(ha)) {
1139 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1140 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1141 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1142 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1145 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1147 mb[3] |= nv->bus[bus].target[target].sync_period;
1149 status = qla1280_mailbox_command(ha, mr, mb);
1151 /* Set Device Queue Parameters. */
1152 for (lun = 0; lun < MAX_LUNS; lun++) {
1153 mb[0] = MBC_SET_DEVICE_QUEUE;
1154 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1156 mb[2] = nv->bus[bus].max_queue_depth;
1157 mb[3] = nv->bus[bus].target[target].execution_throttle;
1158 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1162 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1163 "qla1280_set_target_parameters() failed\n",
1164 ha->host_no, bus, target);
1169 /**************************************************************************
1170 * qla1280_slave_configure
1173 * Determines the queue depth for a given device. There are two ways
1174 * a queue depth can be obtained for a tagged queueing device. One
1175 * way is the default queue depth which is determined by whether
1176 * If it is defined, then it is used
1177 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1178 * default queue depth (dependent on the number of hardware SCBs).
1179 **************************************************************************/
1181 qla1280_slave_configure(struct scsi_device *device)
1183 struct scsi_qla_host *ha;
1184 int default_depth = 3;
1185 int bus = device->channel;
1186 int target = device->id;
1189 unsigned long flags;
1191 ha = (struct scsi_qla_host *)device->host->hostdata;
1194 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1197 if (device->tagged_supported &&
1198 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1199 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1201 scsi_change_queue_depth(device, default_depth);
1204 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1205 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1206 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1208 if (driver_setup.no_sync ||
1209 (driver_setup.sync_mask &&
1210 (~driver_setup.sync_mask & (1 << target))))
1211 nv->bus[bus].target[target].parameter.enable_sync = 0;
1212 if (driver_setup.no_wide ||
1213 (driver_setup.wide_mask &&
1214 (~driver_setup.wide_mask & (1 << target))))
1215 nv->bus[bus].target[target].parameter.enable_wide = 0;
1216 if (IS_ISP1x160(ha)) {
1217 if (driver_setup.no_ppr ||
1218 (driver_setup.ppr_mask &&
1219 (~driver_setup.ppr_mask & (1 << target))))
1220 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1223 spin_lock_irqsave(ha->host->host_lock, flags);
1224 if (nv->bus[bus].target[target].parameter.enable_sync)
1225 status = qla1280_set_target_parameters(ha, bus, target);
1226 qla1280_get_target_parameters(ha, device);
1227 spin_unlock_irqrestore(ha->host->host_lock, flags);
1234 * Process completed commands.
1237 * ha = adapter block pointer.
1240 qla1280_done(struct scsi_qla_host *ha)
1243 struct list_head *done_q;
1245 struct scsi_cmnd *cmd;
1247 ENTER("qla1280_done");
1249 done_q = &ha->done_q;
1251 while (!list_empty(done_q)) {
1252 sp = list_entry(done_q->next, struct srb, list);
1254 list_del(&sp->list);
1257 bus = SCSI_BUS_32(cmd);
1258 target = SCSI_TCN_32(cmd);
1260 switch ((CMD_RESULT(cmd) >> 16)) {
1262 /* Issue marker command. */
1263 if (!ha->flags.abort_isp_active)
1264 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1267 sp->flags &= ~SRB_ABORT_PENDING;
1268 sp->flags |= SRB_ABORTED;
1274 /* Release memory used for this I/O */
1275 scsi_dma_unmap(cmd);
1277 /* Call the mid-level driver interrupt handler */
1280 if (sp->wait == NULL)
1281 (*(cmd)->scsi_done)(cmd);
1285 LEAVE("qla1280_done");
1289 * Translates a ISP error to a Linux SCSI error
1292 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1294 int host_status = DID_ERROR;
1295 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1296 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1297 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1298 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1299 #if DEBUG_QLA1280_INTR
1300 static char *reason[] = {
1312 #endif /* DEBUG_QLA1280_INTR */
1314 ENTER("qla1280_return_status");
1316 #if DEBUG_QLA1280_INTR
1318 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1323 switch (comp_status) {
1325 host_status = DID_OK;
1329 if (!(state_flags & SF_GOT_BUS))
1330 host_status = DID_NO_CONNECT;
1331 else if (!(state_flags & SF_GOT_TARGET))
1332 host_status = DID_BAD_TARGET;
1333 else if (!(state_flags & SF_SENT_CDB))
1334 host_status = DID_ERROR;
1335 else if (!(state_flags & SF_TRANSFERRED_DATA))
1336 host_status = DID_ERROR;
1337 else if (!(state_flags & SF_GOT_STATUS))
1338 host_status = DID_ERROR;
1339 else if (!(state_flags & SF_GOT_SENSE))
1340 host_status = DID_ERROR;
1344 host_status = DID_RESET;
1348 host_status = DID_ABORT;
1352 host_status = DID_TIME_OUT;
1355 case CS_DATA_OVERRUN:
1356 dprintk(2, "Data overrun 0x%x\n", residual_length);
1357 dprintk(2, "qla1280_return_status: response packet data\n");
1358 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1359 host_status = DID_ERROR;
1362 case CS_DATA_UNDERRUN:
1363 if ((scsi_bufflen(cp) - residual_length) <
1366 "scsi: Underflow detected - retrying "
1368 host_status = DID_ERROR;
1370 scsi_set_resid(cp, residual_length);
1371 host_status = DID_OK;
1376 host_status = DID_ERROR;
1380 #if DEBUG_QLA1280_INTR
1381 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1382 reason[host_status], scsi_status);
1385 LEAVE("qla1280_return_status");
1387 return (scsi_status & 0xff) | (host_status << 16);
1390 /****************************************************************************/
1391 /* QLogic ISP1280 Hardware Support Functions. */
1392 /****************************************************************************/
1395 * qla1280_initialize_adapter
1399 * ha = adapter block pointer.
1405 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1407 struct device_reg __iomem *reg;
1410 unsigned long flags;
1412 ENTER("qla1280_initialize_adapter");
1414 /* Clear adapter flags. */
1415 ha->flags.online = 0;
1416 ha->flags.disable_host_adapter = 0;
1417 ha->flags.reset_active = 0;
1418 ha->flags.abort_isp_active = 0;
1420 /* TODO: implement support for the 1040 nvram format */
1422 driver_setup.no_nvram = 1;
1424 dprintk(1, "Configure PCI space for adapter...\n");
1428 /* Insure mailbox registers are free. */
1429 WRT_REG_WORD(®->semaphore, 0);
1430 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1431 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1432 RD_REG_WORD(®->host_cmd);
1434 if (qla1280_read_nvram(ha)) {
1435 dprintk(2, "qla1280_initialize_adapter: failed to read "
1440 * It's necessary to grab the spin here as qla1280_mailbox_command
1441 * needs to be able to drop the lock unconditionally to wait
1444 spin_lock_irqsave(ha->host->host_lock, flags);
1446 status = qla1280_load_firmware(ha);
1448 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1453 /* Setup adapter based on NVRAM parameters. */
1454 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1455 qla1280_nvram_config(ha);
1457 if (ha->flags.disable_host_adapter) {
1462 status = qla1280_init_rings(ha);
1466 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1467 for (bus = 0; bus < ha->ports; bus++) {
1468 if (!ha->bus_settings[bus].disable_scsi_reset &&
1469 qla1280_bus_reset(ha, bus) &&
1470 qla1280_bus_reset(ha, bus))
1471 ha->bus_settings[bus].scsi_bus_dead = 1;
1474 ha->flags.online = 1;
1476 spin_unlock_irqrestore(ha->host->host_lock, flags);
1479 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1481 LEAVE("qla1280_initialize_adapter");
1486 * qla1280_request_firmware
1487 * Acquire firmware for chip. Retain in memory
1488 * for error recovery.
1491 * ha = adapter block pointer.
1494 * Pointer to firmware image or an error code
1495 * cast to pointer via ERR_PTR().
1497 static const struct firmware *
1498 qla1280_request_firmware(struct scsi_qla_host *ha)
1500 const struct firmware *fw;
1505 spin_unlock_irq(ha->host->host_lock);
1506 mutex_lock(&qla1280_firmware_mutex);
1508 index = ql1280_board_tbl[ha->devnum].fw_index;
1509 fw = qla1280_fw_tbl[index].fw;
1513 fwname = qla1280_fw_tbl[index].fwname;
1514 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1517 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1522 if ((fw->size % 2) || (fw->size < 6)) {
1523 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1525 release_firmware(fw);
1526 fw = ERR_PTR(-EINVAL);
1530 qla1280_fw_tbl[index].fw = fw;
1533 ha->fwver1 = fw->data[0];
1534 ha->fwver2 = fw->data[1];
1535 ha->fwver3 = fw->data[2];
1537 mutex_unlock(&qla1280_firmware_mutex);
1538 spin_lock_irq(ha->host->host_lock);
1544 * Test chip for proper operation.
1547 * ha = adapter block pointer.
1553 qla1280_chip_diag(struct scsi_qla_host *ha)
1555 uint16_t mb[MAILBOX_REGISTER_COUNT];
1556 struct device_reg __iomem *reg = ha->iobase;
1560 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1562 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1564 /* Soft reset chip and wait for it to finish. */
1565 WRT_REG_WORD(®->ictrl, ISP_RESET);
1568 * We can't do a traditional PCI write flush here by reading
1569 * back the register. The card will not respond once the reset
1570 * is in action and we end up with a machine check exception
1571 * instead. Nothing to do but wait and hope for the best.
1572 * A portable pci_write_flush(pdev) call would be very useful here.
1575 data = qla1280_debounce_register(®->ictrl);
1577 * Yet another QLogic gem ;-(
1579 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1581 data = RD_REG_WORD(®->ictrl);
1587 /* Reset register cleared by chip reset. */
1588 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1590 WRT_REG_WORD(®->cfg_1, 0);
1592 /* Reset RISC and disable BIOS which
1593 allows RISC to execute out of RAM. */
1594 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1595 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1597 RD_REG_WORD(®->id_l); /* Flush PCI write */
1598 data = qla1280_debounce_register(®->mailbox0);
1601 * I *LOVE* this code!
1603 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1605 data = RD_REG_WORD(®->mailbox0);
1611 /* Check product ID of chip */
1612 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1614 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1615 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1616 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1617 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1618 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1619 printk(KERN_INFO "qla1280: Wrong product ID = "
1620 "0x%x,0x%x,0x%x,0x%x\n",
1621 RD_REG_WORD(®->mailbox1),
1622 RD_REG_WORD(®->mailbox2),
1623 RD_REG_WORD(®->mailbox3),
1624 RD_REG_WORD(®->mailbox4));
1629 * Enable ints early!!!
1631 qla1280_enable_intrs(ha);
1633 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1634 /* Wrap Incoming Mailboxes Test. */
1635 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1644 status = qla1280_mailbox_command(ha, 0xff, mb);
1648 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1649 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1651 printk(KERN_INFO "qla1280: Failed mbox check\n");
1655 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1658 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1663 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1665 /* enter with host_lock acquired */
1667 const struct firmware *fw;
1668 const __le16 *fw_data;
1669 uint16_t risc_address, risc_code_size;
1670 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1673 fw = qla1280_request_firmware(ha);
1677 fw_data = (const __le16 *)&fw->data[0];
1678 ha->fwstart = __le16_to_cpu(fw_data[2]);
1680 /* Load RISC code. */
1681 risc_address = ha->fwstart;
1682 fw_data = (const __le16 *)&fw->data[6];
1683 risc_code_size = (fw->size - 6) / 2;
1685 for (i = 0; i < risc_code_size; i++) {
1686 mb[0] = MBC_WRITE_RAM_WORD;
1687 mb[1] = risc_address + i;
1688 mb[2] = __le16_to_cpu(fw_data[i]);
1690 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1692 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1701 #ifdef QLA_64BIT_PTR
1702 #define LOAD_CMD MBC_LOAD_RAM_A64_ROM
1703 #define DUMP_CMD MBC_DUMP_RAM_A64_ROM
1704 #define CMD_ARGS (BIT_7 | BIT_6 | BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1706 #define LOAD_CMD MBC_LOAD_RAM
1707 #define DUMP_CMD MBC_DUMP_RAM
1708 #define CMD_ARGS (BIT_4 | BIT_3 | BIT_2 | BIT_1 | BIT_0)
1711 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1713 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1715 /* enter with host_lock acquired */
1716 const struct firmware *fw;
1717 const __le16 *fw_data;
1718 uint16_t risc_address, risc_code_size;
1719 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1720 int err = 0, num, i;
1725 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1730 fw = qla1280_request_firmware(ha);
1734 fw_data = (const __le16 *)&fw->data[0];
1735 ha->fwstart = __le16_to_cpu(fw_data[2]);
1737 /* Load RISC code. */
1738 risc_address = ha->fwstart;
1739 fw_data = (const __le16 *)&fw->data[6];
1740 risc_code_size = (fw->size - 6) / 2;
1742 dprintk(1, "%s: DMA RISC code (%i) words\n",
1743 __func__, risc_code_size);
1746 while (risc_code_size > 0) {
1747 int warn __attribute__((unused)) = 0;
1751 if (cnt > risc_code_size)
1752 cnt = risc_code_size;
1754 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1756 fw_data, cnt, num, risc_address);
1757 for(i = 0; i < cnt; i++)
1758 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1761 mb[1] = risc_address;
1763 mb[3] = ha->request_dma & 0xffff;
1764 mb[2] = (ha->request_dma >> 16) & 0xffff;
1765 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1766 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1767 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1769 (void *)(long)ha->request_dma,
1770 mb[6], mb[7], mb[2], mb[3]);
1771 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1773 printk(KERN_ERR "scsi(%li): Failed to load partial "
1774 "segment of f\n", ha->host_no);
1780 mb[1] = risc_address;
1782 mb[3] = p_tbuf & 0xffff;
1783 mb[2] = (p_tbuf >> 16) & 0xffff;
1784 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1785 mb[6] = upper_32_bits(p_tbuf) >> 16;
1787 err = qla1280_mailbox_command(ha, CMD_ARGS, mb);
1790 "Failed to dump partial segment of f/w\n");
1793 sp = (uint8_t *)ha->request_ring;
1794 for (i = 0; i < (cnt << 1); i++) {
1795 if (tbuf[i] != sp[i] && warn++ < 10) {
1796 printk(KERN_ERR "%s: FW compare error @ "
1797 "byte(0x%x) loop#=%x\n",
1799 printk(KERN_ERR "%s: FWbyte=%x "
1801 __func__, sp[i], tbuf[i]);
1806 risc_address += cnt;
1807 risc_code_size = risc_code_size - cnt;
1808 fw_data = fw_data + cnt;
1814 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1820 qla1280_start_firmware(struct scsi_qla_host *ha)
1822 uint16_t mb[MAILBOX_REGISTER_COUNT];
1825 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1828 /* Verify checksum of loaded RISC code. */
1829 mb[0] = MBC_VERIFY_CHECKSUM;
1830 /* mb[1] = ql12_risc_code_addr01; */
1831 mb[1] = ha->fwstart;
1832 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1834 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1838 /* Start firmware execution. */
1839 dprintk(1, "%s: start firmware running.\n", __func__);
1840 mb[0] = MBC_EXECUTE_FIRMWARE;
1841 mb[1] = ha->fwstart;
1842 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1844 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1852 qla1280_load_firmware(struct scsi_qla_host *ha)
1854 /* enter with host_lock taken */
1857 err = qla1280_chip_diag(ha);
1861 err = qla1280_load_firmware_pio(ha);
1863 err = qla1280_load_firmware_dma(ha);
1866 err = qla1280_start_firmware(ha);
1875 * ha = adapter block pointer.
1876 * ha->request_ring = request ring virtual address
1877 * ha->response_ring = response ring virtual address
1878 * ha->request_dma = request ring physical address
1879 * ha->response_dma = response ring physical address
1885 qla1280_init_rings(struct scsi_qla_host *ha)
1887 uint16_t mb[MAILBOX_REGISTER_COUNT];
1890 ENTER("qla1280_init_rings");
1892 /* Clear outstanding commands array. */
1893 memset(ha->outstanding_cmds, 0,
1894 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1896 /* Initialize request queue. */
1897 ha->request_ring_ptr = ha->request_ring;
1898 ha->req_ring_index = 0;
1899 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1900 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1901 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1902 mb[1] = REQUEST_ENTRY_CNT;
1903 mb[3] = ha->request_dma & 0xffff;
1904 mb[2] = (ha->request_dma >> 16) & 0xffff;
1906 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1907 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1908 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1909 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1911 /* Initialize response queue. */
1912 ha->response_ring_ptr = ha->response_ring;
1913 ha->rsp_ring_index = 0;
1914 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1915 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1916 mb[1] = RESPONSE_ENTRY_CNT;
1917 mb[3] = ha->response_dma & 0xffff;
1918 mb[2] = (ha->response_dma >> 16) & 0xffff;
1920 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1921 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1922 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1923 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1928 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1930 LEAVE("qla1280_init_rings");
1935 qla1280_print_settings(struct nvram *nv)
1937 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1938 nv->bus[0].config_1.initiator_id);
1939 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1940 nv->bus[1].config_1.initiator_id);
1942 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1943 nv->bus[0].bus_reset_delay);
1944 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1945 nv->bus[1].bus_reset_delay);
1947 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1948 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1949 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1950 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1952 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1953 nv->bus[0].config_2.async_data_setup_time);
1954 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1955 nv->bus[1].config_2.async_data_setup_time);
1957 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1958 nv->bus[0].config_2.req_ack_active_negation);
1959 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1960 nv->bus[1].config_2.req_ack_active_negation);
1962 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1963 nv->bus[0].config_2.data_line_active_negation);
1964 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1965 nv->bus[1].config_2.data_line_active_negation);
1967 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1968 nv->cntr_flags_1.disable_loading_risc_code);
1970 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1971 nv->cntr_flags_1.enable_64bit_addressing);
1973 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1974 nv->bus[0].selection_timeout);
1975 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1976 nv->bus[1].selection_timeout);
1978 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1979 nv->bus[0].max_queue_depth);
1980 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1981 nv->bus[1].max_queue_depth);
1985 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1987 struct nvram *nv = &ha->nvram;
1989 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
1990 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
1991 nv->bus[bus].target[target].parameter.tag_queuing = 1;
1992 nv->bus[bus].target[target].parameter.enable_sync = 1;
1993 #if 1 /* Some SCSI Processors do not seem to like this */
1994 nv->bus[bus].target[target].parameter.enable_wide = 1;
1996 nv->bus[bus].target[target].execution_throttle =
1997 nv->bus[bus].max_queue_depth - 1;
1998 nv->bus[bus].target[target].parameter.parity_checking = 1;
1999 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
2001 if (IS_ISP1x160(ha)) {
2002 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2003 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2004 nv->bus[bus].target[target].sync_period = 9;
2005 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2006 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2007 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2009 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2010 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2011 nv->bus[bus].target[target].sync_period = 10;
2016 qla1280_set_defaults(struct scsi_qla_host *ha)
2018 struct nvram *nv = &ha->nvram;
2021 dprintk(1, "Using defaults for NVRAM: \n");
2022 memset(nv, 0, sizeof(struct nvram));
2024 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2025 nv->firmware_feature.f.enable_fast_posting = 1;
2026 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2027 nv->termination.scsi_bus_0_control = 3;
2028 nv->termination.scsi_bus_1_control = 3;
2029 nv->termination.auto_term_support = 1;
2032 * Set default FIFO magic - What appropriate values would be here
2033 * is unknown. This is what I have found testing with 12160s.
2035 * Now, I would love the magic decoder ring for this one, the
2036 * header file provided by QLogic seems to be bogus or incomplete
2039 nv->isp_config.burst_enable = 1;
2041 nv->isp_config.fifo_threshold |= 3;
2043 nv->isp_config.fifo_threshold |= 4;
2045 if (IS_ISP1x160(ha))
2046 nv->isp_parameter = 0x01; /* fast memory enable */
2048 for (bus = 0; bus < MAX_BUSES; bus++) {
2049 nv->bus[bus].config_1.initiator_id = 7;
2050 nv->bus[bus].config_2.req_ack_active_negation = 1;
2051 nv->bus[bus].config_2.data_line_active_negation = 1;
2052 nv->bus[bus].selection_timeout = 250;
2053 nv->bus[bus].max_queue_depth = 32;
2055 if (IS_ISP1040(ha)) {
2056 nv->bus[bus].bus_reset_delay = 3;
2057 nv->bus[bus].config_2.async_data_setup_time = 6;
2058 nv->bus[bus].retry_delay = 1;
2060 nv->bus[bus].bus_reset_delay = 5;
2061 nv->bus[bus].config_2.async_data_setup_time = 8;
2064 for (target = 0; target < MAX_TARGETS; target++)
2065 qla1280_set_target_defaults(ha, bus, target);
2070 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2072 struct nvram *nv = &ha->nvram;
2073 uint16_t mb[MAILBOX_REGISTER_COUNT];
2077 /* Set Target Parameters. */
2078 mb[0] = MBC_SET_TARGET_PARAMETERS;
2079 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2082 * Do not enable sync and ppr for the initial INQUIRY run. We
2083 * enable this later if we determine the target actually
2086 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2087 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2089 if (IS_ISP1x160(ha))
2090 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2092 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2093 mb[3] |= nv->bus[bus].target[target].sync_period;
2094 status = qla1280_mailbox_command(ha, 0x0f, mb);
2096 /* Save Tag queuing enable flag. */
2097 flag = (BIT_0 << target);
2098 if (nv->bus[bus].target[target].parameter.tag_queuing)
2099 ha->bus_settings[bus].qtag_enables |= flag;
2101 /* Save Device enable flag. */
2102 if (IS_ISP1x160(ha)) {
2103 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2104 ha->bus_settings[bus].device_enables |= flag;
2105 ha->bus_settings[bus].lun_disables |= 0;
2107 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2108 ha->bus_settings[bus].device_enables |= flag;
2109 /* Save LUN disable flag. */
2110 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2111 ha->bus_settings[bus].lun_disables |= flag;
2114 /* Set Device Queue Parameters. */
2115 for (lun = 0; lun < MAX_LUNS; lun++) {
2116 mb[0] = MBC_SET_DEVICE_QUEUE;
2117 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2119 mb[2] = nv->bus[bus].max_queue_depth;
2120 mb[3] = nv->bus[bus].target[target].execution_throttle;
2121 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2128 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2130 struct nvram *nv = &ha->nvram;
2131 uint16_t mb[MAILBOX_REGISTER_COUNT];
2134 /* SCSI Reset Disable. */
2135 ha->bus_settings[bus].disable_scsi_reset =
2136 nv->bus[bus].config_1.scsi_reset_disable;
2139 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2140 mb[0] = MBC_SET_INITIATOR_ID;
2141 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2142 ha->bus_settings[bus].id;
2143 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2146 ha->bus_settings[bus].bus_reset_delay =
2147 nv->bus[bus].bus_reset_delay;
2149 /* Command queue depth per device. */
2150 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2152 /* Set target parameters. */
2153 for (target = 0; target < MAX_TARGETS; target++)
2154 status |= qla1280_config_target(ha, bus, target);
2160 qla1280_nvram_config(struct scsi_qla_host *ha)
2162 struct device_reg __iomem *reg = ha->iobase;
2163 struct nvram *nv = &ha->nvram;
2164 int bus, target, status = 0;
2165 uint16_t mb[MAILBOX_REGISTER_COUNT];
2167 ENTER("qla1280_nvram_config");
2169 if (ha->nvram_valid) {
2170 /* Always force AUTO sense for LINUX SCSI */
2171 for (bus = 0; bus < MAX_BUSES; bus++)
2172 for (target = 0; target < MAX_TARGETS; target++) {
2173 nv->bus[bus].target[target].parameter.
2174 auto_request_sense = 1;
2177 qla1280_set_defaults(ha);
2180 qla1280_print_settings(nv);
2182 /* Disable RISC load of firmware. */
2183 ha->flags.disable_risc_code_load =
2184 nv->cntr_flags_1.disable_loading_risc_code;
2186 if (IS_ISP1040(ha)) {
2187 uint16_t hwrev, cfg1, cdma_conf;
2189 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2191 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2192 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2194 /* Busted fifo, says mjacob. */
2195 if (hwrev != ISP_CFG0_1040A)
2196 cfg1 |= nv->isp_config.fifo_threshold << 4;
2198 cfg1 |= nv->isp_config.burst_enable << 2;
2199 WRT_REG_WORD(®->cfg_1, cfg1);
2201 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2202 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2204 uint16_t cfg1, term;
2206 /* Set ISP hardware DMA burst */
2207 cfg1 = nv->isp_config.fifo_threshold << 4;
2208 cfg1 |= nv->isp_config.burst_enable << 2;
2209 /* Enable DMA arbitration on dual channel controllers */
2212 WRT_REG_WORD(®->cfg_1, cfg1);
2214 /* Set SCSI termination. */
2215 WRT_REG_WORD(®->gpio_enable,
2216 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2217 term = nv->termination.scsi_bus_1_control;
2218 term |= nv->termination.scsi_bus_0_control << 2;
2219 term |= nv->termination.auto_term_support << 7;
2220 RD_REG_WORD(®->id_l); /* Flush PCI write */
2221 WRT_REG_WORD(®->gpio_data, term);
2223 RD_REG_WORD(®->id_l); /* Flush PCI write */
2225 /* ISP parameter word. */
2226 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2227 mb[1] = nv->isp_parameter;
2228 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2230 if (IS_ISP1x40(ha)) {
2231 /* clock rate - for qla1240 and older, only */
2232 mb[0] = MBC_SET_CLOCK_RATE;
2234 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2237 /* Firmware feature word. */
2238 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2239 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2240 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2241 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2242 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2244 /* Retry count and delay. */
2245 mb[0] = MBC_SET_RETRY_COUNT;
2246 mb[1] = nv->bus[0].retry_count;
2247 mb[2] = nv->bus[0].retry_delay;
2248 mb[6] = nv->bus[1].retry_count;
2249 mb[7] = nv->bus[1].retry_delay;
2250 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2251 BIT_1 | BIT_0, &mb[0]);
2253 /* ASYNC data setup time. */
2254 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2255 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2256 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2257 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2259 /* Active negation states. */
2260 mb[0] = MBC_SET_ACTIVE_NEGATION;
2262 if (nv->bus[0].config_2.req_ack_active_negation)
2264 if (nv->bus[0].config_2.data_line_active_negation)
2267 if (nv->bus[1].config_2.req_ack_active_negation)
2269 if (nv->bus[1].config_2.data_line_active_negation)
2271 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2273 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2274 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2275 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2278 mb[0] = MBC_SET_PCI_CONTROL;
2279 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2280 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2281 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2283 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2285 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2287 /* Selection timeout. */
2288 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2289 mb[1] = nv->bus[0].selection_timeout;
2290 mb[2] = nv->bus[1].selection_timeout;
2291 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2293 for (bus = 0; bus < ha->ports; bus++)
2294 status |= qla1280_config_bus(ha, bus);
2297 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2299 LEAVE("qla1280_nvram_config");
2304 * Get NVRAM data word
2305 * Calculates word position in NVRAM and calls request routine to
2306 * get the word from NVRAM.
2309 * ha = adapter block pointer.
2310 * address = NVRAM word address.
2316 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2321 nv_cmd = address << 16;
2322 nv_cmd |= NV_READ_OP;
2324 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2326 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2334 * Sends read command to NVRAM and gets data from NVRAM.
2337 * ha = adapter block pointer.
2338 * nv_cmd = Bit 26 = start bit
2339 * Bit 25, 24 = opcode
2340 * Bit 23-16 = address
2341 * Bit 15-0 = write data
2347 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2349 struct device_reg __iomem *reg = ha->iobase;
2354 /* Send command to NVRAM. */
2357 for (cnt = 0; cnt < 11; cnt++) {
2358 if (nv_cmd & BIT_31)
2359 qla1280_nv_write(ha, NV_DATA_OUT);
2361 qla1280_nv_write(ha, 0);
2365 /* Read data from NVRAM. */
2367 for (cnt = 0; cnt < 16; cnt++) {
2368 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2369 RD_REG_WORD(®->id_l); /* Flush PCI write */
2372 reg_data = RD_REG_WORD(®->nvram);
2373 if (reg_data & NV_DATA_IN)
2375 WRT_REG_WORD(®->nvram, NV_SELECT);
2376 RD_REG_WORD(®->id_l); /* Flush PCI write */
2380 /* Deselect chip. */
2382 WRT_REG_WORD(®->nvram, NV_DESELECT);
2383 RD_REG_WORD(®->id_l); /* Flush PCI write */
2390 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2392 struct device_reg __iomem *reg = ha->iobase;
2394 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2395 RD_REG_WORD(®->id_l); /* Flush PCI write */
2397 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2398 RD_REG_WORD(®->id_l); /* Flush PCI write */
2400 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2401 RD_REG_WORD(®->id_l); /* Flush PCI write */
2407 * Issue mailbox command and waits for completion.
2410 * ha = adapter block pointer.
2411 * mr = mailbox registers to load.
2412 * mb = data pointer for mailbox registers.
2415 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2421 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2423 struct device_reg __iomem *reg = ha->iobase;
2426 uint16_t *optr, *iptr;
2427 uint16_t __iomem *mptr;
2428 DECLARE_COMPLETION_ONSTACK(wait);
2430 ENTER("qla1280_mailbox_command");
2432 if (ha->mailbox_wait) {
2433 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2435 ha->mailbox_wait = &wait;
2438 * We really should start out by verifying that the mailbox is
2439 * available before starting sending the command data
2441 /* Load mailbox registers. */
2442 mptr = (uint16_t __iomem *) ®->mailbox0;
2444 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2446 WRT_REG_WORD(mptr, (*iptr));
2454 /* Issue set host interrupt command. */
2456 /* set up a timer just in case we're really jammed */
2457 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2458 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
2460 spin_unlock_irq(ha->host->host_lock);
2461 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2462 qla1280_debounce_register(®->istatus);
2464 wait_for_completion(&wait);
2465 del_timer_sync(&ha->mailbox_timer);
2467 spin_lock_irq(ha->host->host_lock);
2469 ha->mailbox_wait = NULL;
2471 /* Check for mailbox command timeout. */
2472 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2473 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2474 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2476 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2477 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2478 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2479 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2480 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2481 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2482 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2486 /* Load return mailbox registers. */
2488 iptr = (uint16_t *) &ha->mailbox_out[0];
2489 mr = MAILBOX_REGISTER_COUNT;
2490 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2492 if (ha->flags.reset_marker)
2493 qla1280_rst_aen(ha);
2496 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2497 "0x%x ****\n", mb[0]);
2499 LEAVE("qla1280_mailbox_command");
2505 * Polls ISP for interrupts.
2508 * ha = adapter block pointer.
2511 qla1280_poll(struct scsi_qla_host *ha)
2513 struct device_reg __iomem *reg = ha->iobase;
2517 /* ENTER("qla1280_poll"); */
2519 /* Check for pending interrupts. */
2520 data = RD_REG_WORD(®->istatus);
2521 if (data & RISC_INT)
2522 qla1280_isr(ha, &done_q);
2524 if (!ha->mailbox_wait) {
2525 if (ha->flags.reset_marker)
2526 qla1280_rst_aen(ha);
2529 if (!list_empty(&done_q))
2532 /* LEAVE("qla1280_poll"); */
2537 * Issue SCSI bus reset.
2540 * ha = adapter block pointer.
2541 * bus = SCSI bus number.
2547 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2549 uint16_t mb[MAILBOX_REGISTER_COUNT];
2550 uint16_t reset_delay;
2553 dprintk(3, "qla1280_bus_reset: entered\n");
2555 if (qla1280_verbose)
2556 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2559 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2560 mb[0] = MBC_BUS_RESET;
2561 mb[1] = reset_delay;
2562 mb[2] = (uint16_t) bus;
2563 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2566 if (ha->bus_settings[bus].failed_reset_count > 2)
2567 ha->bus_settings[bus].scsi_bus_dead = 1;
2568 ha->bus_settings[bus].failed_reset_count++;
2570 spin_unlock_irq(ha->host->host_lock);
2571 ssleep(reset_delay);
2572 spin_lock_irq(ha->host->host_lock);
2574 ha->bus_settings[bus].scsi_bus_dead = 0;
2575 ha->bus_settings[bus].failed_reset_count = 0;
2576 ha->bus_settings[bus].reset_marker = 0;
2577 /* Issue marker command. */
2578 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2582 * We should probably call qla1280_set_target_parameters()
2583 * here as well for all devices on the bus.
2587 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2589 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2595 * qla1280_device_reset
2596 * Issue bus device reset message to the target.
2599 * ha = adapter block pointer.
2600 * bus = SCSI BUS number.
2607 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2609 uint16_t mb[MAILBOX_REGISTER_COUNT];
2612 ENTER("qla1280_device_reset");
2614 mb[0] = MBC_ABORT_TARGET;
2615 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2617 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2619 /* Issue marker command. */
2620 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2623 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2625 LEAVE("qla1280_device_reset");
2630 * qla1280_abort_command
2631 * Abort command aborts a specified IOCB.
2634 * ha = adapter block pointer.
2635 * sp = SB structure pointer.
2641 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2643 uint16_t mb[MAILBOX_REGISTER_COUNT];
2644 unsigned int bus, target, lun;
2647 ENTER("qla1280_abort_command");
2649 bus = SCSI_BUS_32(sp->cmd);
2650 target = SCSI_TCN_32(sp->cmd);
2651 lun = SCSI_LUN_32(sp->cmd);
2653 sp->flags |= SRB_ABORT_PENDING;
2655 mb[0] = MBC_ABORT_COMMAND;
2656 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2657 mb[2] = handle >> 16;
2658 mb[3] = handle & 0xffff;
2659 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2662 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2663 sp->flags &= ~SRB_ABORT_PENDING;
2667 LEAVE("qla1280_abort_command");
2672 * qla1280_reset_adapter
2676 * ha = adapter block pointer.
2679 qla1280_reset_adapter(struct scsi_qla_host *ha)
2681 struct device_reg __iomem *reg = ha->iobase;
2683 ENTER("qla1280_reset_adapter");
2685 /* Disable ISP chip */
2686 ha->flags.online = 0;
2687 WRT_REG_WORD(®->ictrl, ISP_RESET);
2688 WRT_REG_WORD(®->host_cmd,
2689 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2690 RD_REG_WORD(®->id_l); /* Flush PCI write */
2692 LEAVE("qla1280_reset_adapter");
2696 * Issue marker command.
2697 * Function issues marker IOCB.
2700 * ha = adapter block pointer.
2701 * bus = SCSI BUS number
2704 * type = marker modifier
2707 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2709 struct mrk_entry *pkt;
2711 ENTER("qla1280_marker");
2713 /* Get request packet. */
2714 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2715 pkt->entry_type = MARKER_TYPE;
2716 pkt->lun = (uint8_t) lun;
2717 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2718 pkt->modifier = type;
2719 pkt->entry_status = 0;
2721 /* Issue command to ISP */
2722 qla1280_isp_cmd(ha);
2725 LEAVE("qla1280_marker");
2730 * qla1280_64bit_start_scsi
2731 * The start SCSI is responsible for building request packets on
2732 * request ring and modifying ISP input pointer.
2735 * ha = adapter block pointer.
2736 * sp = SB structure pointer.
2739 * 0 = success, was able to issue command.
2741 #ifdef QLA_64BIT_PTR
2743 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2745 struct device_reg __iomem *reg = ha->iobase;
2746 struct scsi_cmnd *cmd = sp->cmd;
2747 cmd_a64_entry_t *pkt;
2749 dma_addr_t dma_handle;
2756 ENTER("qla1280_64bit_start_scsi:");
2758 /* Calculate number of entries and segments required. */
2760 seg_cnt = scsi_dma_map(cmd);
2763 req_cnt += (seg_cnt - 2) / 5;
2764 if ((seg_cnt - 2) % 5)
2767 } else if (seg_cnt < 0) {
2772 if ((req_cnt + 2) >= ha->req_q_cnt) {
2773 /* Calculate number of free request entries. */
2774 cnt = RD_REG_WORD(®->mailbox4);
2775 if (ha->req_ring_index < cnt)
2776 ha->req_q_cnt = cnt - ha->req_ring_index;
2779 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2782 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2783 ha->req_q_cnt, seg_cnt);
2785 /* If room for request in request ring. */
2786 if ((req_cnt + 2) >= ha->req_q_cnt) {
2787 status = SCSI_MLQUEUE_HOST_BUSY;
2788 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
2789 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2794 /* Check for room in outstanding command list. */
2795 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2796 ha->outstanding_cmds[cnt] != NULL; cnt++);
2798 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2799 status = SCSI_MLQUEUE_HOST_BUSY;
2800 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2801 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2805 ha->outstanding_cmds[cnt] = sp;
2806 ha->req_q_cnt -= req_cnt;
2807 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2809 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2810 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2811 dprintk(2, " bus %i, target %i, lun %i\n",
2812 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2813 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2816 * Build command packet.
2818 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2820 pkt->entry_type = COMMAND_A64_TYPE;
2821 pkt->entry_count = (uint8_t) req_cnt;
2822 pkt->sys_define = (uint8_t) ha->req_ring_index;
2823 pkt->entry_status = 0;
2824 pkt->handle = cpu_to_le32(cnt);
2826 /* Zero out remaining portion of packet. */
2827 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2829 /* Set ISP command timeout. */
2830 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
2832 /* Set device target ID and LUN */
2833 pkt->lun = SCSI_LUN_32(cmd);
2834 pkt->target = SCSI_BUS_32(cmd) ?
2835 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2837 /* Enable simple tag queuing if device supports it. */
2838 if (cmd->device->simple_tags)
2839 pkt->control_flags |= cpu_to_le16(BIT_3);
2841 /* Load SCSI command packet. */
2842 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2843 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
2844 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2846 /* Set transfer direction. */
2847 dir = qla1280_data_direction(cmd);
2848 pkt->control_flags |= cpu_to_le16(dir);
2850 /* Set total data segment count. */
2851 pkt->dseg_count = cpu_to_le16(seg_cnt);
2854 * Load data segments.
2856 if (seg_cnt) { /* If data transfer. */
2857 struct scatterlist *sg, *s;
2858 int remseg = seg_cnt;
2860 sg = scsi_sglist(cmd);
2862 /* Setup packet address segment pointer. */
2863 dword_ptr = (u32 *)&pkt->dseg_0_address;
2865 /* Load command entry data segments. */
2866 for_each_sg(sg, s, seg_cnt, cnt) {
2870 dma_handle = sg_dma_address(s);
2872 cpu_to_le32(lower_32_bits(dma_handle));
2874 cpu_to_le32(upper_32_bits(dma_handle));
2875 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2876 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2877 cpu_to_le32(upper_32_bits(dma_handle)),
2878 cpu_to_le32(lower_32_bits(dma_handle)),
2879 cpu_to_le32(sg_dma_len(sg_next(s))));
2882 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2883 "command packet data - b %i, t %i, l %i \n",
2884 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2886 qla1280_dump_buffer(5, (char *)pkt,
2887 REQUEST_ENTRY_SIZE);
2890 * Build continuation packets.
2892 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2893 "remains\n", seg_cnt);
2895 while (remseg > 0) {
2896 /* Update sg start */
2898 /* Adjust ring index. */
2899 ha->req_ring_index++;
2900 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2901 ha->req_ring_index = 0;
2902 ha->request_ring_ptr =
2905 ha->request_ring_ptr++;
2907 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2909 /* Zero out packet. */
2910 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2912 /* Load packet defaults. */
2913 ((struct cont_a64_entry *) pkt)->entry_type =
2915 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2916 ((struct cont_a64_entry *) pkt)->sys_define =
2917 (uint8_t)ha->req_ring_index;
2918 /* Setup packet address segment pointer. */
2920 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2922 /* Load continuation entry data segments. */
2923 for_each_sg(sg, s, remseg, cnt) {
2926 dma_handle = sg_dma_address(s);
2928 cpu_to_le32(lower_32_bits(dma_handle));
2930 cpu_to_le32(upper_32_bits(dma_handle));
2932 cpu_to_le32(sg_dma_len(s));
2933 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2934 cpu_to_le32(upper_32_bits(dma_handle)),
2935 cpu_to_le32(lower_32_bits(dma_handle)),
2936 cpu_to_le32(sg_dma_len(s)));
2939 dprintk(5, "qla1280_64bit_start_scsi: "
2940 "continuation packet data - b %i, t "
2941 "%i, l %i \n", SCSI_BUS_32(cmd),
2942 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2943 qla1280_dump_buffer(5, (char *)pkt,
2944 REQUEST_ENTRY_SIZE);
2946 } else { /* No data transfer */
2947 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2948 "packet data - b %i, t %i, l %i \n",
2949 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2950 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2952 /* Adjust ring index. */
2953 ha->req_ring_index++;
2954 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2955 ha->req_ring_index = 0;
2956 ha->request_ring_ptr = ha->request_ring;
2958 ha->request_ring_ptr++;
2960 /* Set chip new ring index. */
2962 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
2963 sp->flags |= SRB_SENT;
2965 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
2969 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
2971 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
2975 #else /* !QLA_64BIT_PTR */
2978 * qla1280_32bit_start_scsi
2979 * The start SCSI is responsible for building request packets on
2980 * request ring and modifying ISP input pointer.
2982 * The Qlogic firmware interface allows every queue slot to have a SCSI
2983 * command and up to 4 scatter/gather (SG) entries. If we need more
2984 * than 4 SG entries, then continuation entries are used that can
2985 * hold another 7 entries each. The start routine determines if there
2986 * is eought empty slots then build the combination of requests to
2987 * fulfill the OS request.
2990 * ha = adapter block pointer.
2991 * sp = SCSI Request Block structure pointer.
2994 * 0 = success, was able to issue command.
2997 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2999 struct device_reg __iomem *reg = ha->iobase;
3000 struct scsi_cmnd *cmd = sp->cmd;
3001 struct cmd_entry *pkt;
3009 ENTER("qla1280_32bit_start_scsi");
3011 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3014 /* Calculate number of entries and segments required. */
3016 seg_cnt = scsi_dma_map(cmd);
3019 * if greater than four sg entries then we need to allocate
3020 * continuation entries
3023 req_cnt += (seg_cnt - 4) / 7;
3024 if ((seg_cnt - 4) % 7)
3027 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3028 cmd, seg_cnt, req_cnt);
3029 } else if (seg_cnt < 0) {
3034 if ((req_cnt + 2) >= ha->req_q_cnt) {
3035 /* Calculate number of free request entries. */
3036 cnt = RD_REG_WORD(®->mailbox4);
3037 if (ha->req_ring_index < cnt)
3038 ha->req_q_cnt = cnt - ha->req_ring_index;
3041 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3044 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3045 ha->req_q_cnt, seg_cnt);
3046 /* If room for request in request ring. */
3047 if ((req_cnt + 2) >= ha->req_q_cnt) {
3048 status = SCSI_MLQUEUE_HOST_BUSY;
3049 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3050 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3051 ha->req_q_cnt, req_cnt);
3055 /* Check for empty slot in outstanding command list. */
3056 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3057 (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3059 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3060 status = SCSI_MLQUEUE_HOST_BUSY;
3061 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3062 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3066 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3067 ha->outstanding_cmds[cnt] = sp;
3068 ha->req_q_cnt -= req_cnt;
3071 * Build command packet.
3073 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3075 pkt->entry_type = COMMAND_TYPE;
3076 pkt->entry_count = (uint8_t) req_cnt;
3077 pkt->sys_define = (uint8_t) ha->req_ring_index;
3078 pkt->entry_status = 0;
3079 pkt->handle = cpu_to_le32(cnt);
3081 /* Zero out remaining portion of packet. */
3082 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3084 /* Set ISP command timeout. */
3085 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
3087 /* Set device target ID and LUN */
3088 pkt->lun = SCSI_LUN_32(cmd);
3089 pkt->target = SCSI_BUS_32(cmd) ?
3090 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3092 /* Enable simple tag queuing if device supports it. */
3093 if (cmd->device->simple_tags)
3094 pkt->control_flags |= cpu_to_le16(BIT_3);
3096 /* Load SCSI command packet. */
3097 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3098 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
3100 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3101 /* Set transfer direction. */
3102 dir = qla1280_data_direction(cmd);
3103 pkt->control_flags |= cpu_to_le16(dir);
3105 /* Set total data segment count. */
3106 pkt->dseg_count = cpu_to_le16(seg_cnt);
3109 * Load data segments.
3112 struct scatterlist *sg, *s;
3113 int remseg = seg_cnt;
3115 sg = scsi_sglist(cmd);
3117 /* Setup packet address segment pointer. */
3118 dword_ptr = &pkt->dseg_0_address;
3120 dprintk(3, "Building S/G data segments..\n");
3121 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3123 /* Load command entry data segments. */
3124 for_each_sg(sg, s, seg_cnt, cnt) {
3128 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3129 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3130 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3131 (lower_32_bits(sg_dma_address(s))),
3136 * Build continuation packets.
3138 dprintk(3, "S/G Building Continuation"
3139 "...seg_cnt=0x%x remains\n", seg_cnt);
3140 while (remseg > 0) {
3141 /* Continue from end point */
3143 /* Adjust ring index. */
3144 ha->req_ring_index++;
3145 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3146 ha->req_ring_index = 0;
3147 ha->request_ring_ptr =
3150 ha->request_ring_ptr++;
3152 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3154 /* Zero out packet. */
3155 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3157 /* Load packet defaults. */
3158 ((struct cont_entry *) pkt)->
3159 entry_type = CONTINUE_TYPE;
3160 ((struct cont_entry *) pkt)->entry_count = 1;
3162 ((struct cont_entry *) pkt)->sys_define =
3163 (uint8_t) ha->req_ring_index;
3165 /* Setup packet address segment pointer. */
3167 &((struct cont_entry *) pkt)->dseg_0_address;
3169 /* Load continuation entry data segments. */
3170 for_each_sg(sg, s, remseg, cnt) {
3174 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3176 cpu_to_le32(sg_dma_len(s));
3178 "S/G Segment Cont. phys_addr=0x%x, "
3180 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
3181 cpu_to_le32(sg_dma_len(s)));
3184 dprintk(5, "qla1280_32bit_start_scsi: "
3185 "continuation packet data - "
3186 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3187 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3188 qla1280_dump_buffer(5, (char *)pkt,
3189 REQUEST_ENTRY_SIZE);
3191 } else { /* No data transfer at all */
3192 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3193 "packet data - \n");
3194 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3196 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3197 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3198 REQUEST_ENTRY_SIZE);
3200 /* Adjust ring index. */
3201 ha->req_ring_index++;
3202 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3203 ha->req_ring_index = 0;
3204 ha->request_ring_ptr = ha->request_ring;
3206 ha->request_ring_ptr++;
3208 /* Set chip new ring index. */
3209 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3210 "for pending command\n");
3211 sp->flags |= SRB_SENT;
3213 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3217 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3219 LEAVE("qla1280_32bit_start_scsi");
3227 * Function is responsible for locking ring and
3228 * getting a zeroed out request packet.
3231 * ha = adapter block pointer.
3234 * 0 = failed to get slot.
3237 qla1280_req_pkt(struct scsi_qla_host *ha)
3239 struct device_reg __iomem *reg = ha->iobase;
3240 request_t *pkt = NULL;
3244 ENTER("qla1280_req_pkt");
3247 * This can be called from interrupt context, damn it!!!
3249 /* Wait for 30 seconds for slot. */
3250 for (timer = 15000000; timer; timer--) {
3251 if (ha->req_q_cnt > 0) {
3252 /* Calculate number of free request entries. */
3253 cnt = RD_REG_WORD(®->mailbox4);
3254 if (ha->req_ring_index < cnt)
3255 ha->req_q_cnt = cnt - ha->req_ring_index;
3258 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3261 /* Found empty request ring slot? */
3262 if (ha->req_q_cnt > 0) {
3264 pkt = ha->request_ring_ptr;
3266 /* Zero out packet. */
3267 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3270 * How can this be right when we have a ring
3273 /* Set system defined field. */
3274 pkt->sys_define = (uint8_t) ha->req_ring_index;
3276 /* Set entry count. */
3277 pkt->entry_count = 1;
3284 /* Check for pending interrupts. */
3289 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3291 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3298 * Function is responsible for modifying ISP input pointer.
3299 * Releases ring lock.
3302 * ha = adapter block pointer.
3305 qla1280_isp_cmd(struct scsi_qla_host *ha)
3307 struct device_reg __iomem *reg = ha->iobase;
3309 ENTER("qla1280_isp_cmd");
3311 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3312 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3313 REQUEST_ENTRY_SIZE);
3315 /* Adjust ring index. */
3316 ha->req_ring_index++;
3317 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3318 ha->req_ring_index = 0;
3319 ha->request_ring_ptr = ha->request_ring;
3321 ha->request_ring_ptr++;
3324 * Update request index to mailbox4 (Request Queue In).
3326 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3328 LEAVE("qla1280_isp_cmd");
3331 /****************************************************************************/
3332 /* Interrupt Service Routine. */
3333 /****************************************************************************/
3335 /****************************************************************************
3337 * Calls I/O done on command completion.
3340 * ha = adapter block pointer.
3341 * done_q = done queue.
3342 ****************************************************************************/
3344 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3346 struct device_reg __iomem *reg = ha->iobase;
3347 struct response *pkt;
3348 struct srb *sp = NULL;
3349 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3354 ENTER("qla1280_isr");
3356 istatus = RD_REG_WORD(®->istatus);
3357 if (!(istatus & (RISC_INT | PCI_INT)))
3360 /* Save mailbox register 5 */
3361 mailbox[5] = RD_REG_WORD(®->mailbox5);
3363 /* Check for mailbox interrupt. */
3365 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3367 if (mailbox[0] & BIT_0) {
3368 /* Get mailbox data. */
3369 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3372 *wptr++ = RD_REG_WORD(®->mailbox0);
3373 *wptr++ = RD_REG_WORD(®->mailbox1);
3374 *wptr = RD_REG_WORD(®->mailbox2);
3375 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3377 *wptr++ = RD_REG_WORD(®->mailbox3);
3378 *wptr++ = RD_REG_WORD(®->mailbox4);
3380 *wptr++ = RD_REG_WORD(®->mailbox6);
3381 *wptr = RD_REG_WORD(®->mailbox7);
3384 /* Release mailbox registers. */
3386 WRT_REG_WORD(®->semaphore, 0);
3387 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3389 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3392 /* Handle asynchronous event */
3393 switch (mailbox[0]) {
3394 case MBA_SCSI_COMPLETION: /* Response completion */
3395 dprintk(5, "qla1280_isr: mailbox SCSI response "
3398 if (ha->flags.online) {
3399 /* Get outstanding command index. */
3400 index = mailbox[2] << 16 | mailbox[1];
3402 /* Validate handle. */
3403 if (index < MAX_OUTSTANDING_COMMANDS)
3404 sp = ha->outstanding_cmds[index];
3409 /* Free outstanding command slot. */
3410 ha->outstanding_cmds[index] = NULL;
3412 /* Save ISP completion status */
3413 CMD_RESULT(sp->cmd) = 0;
3414 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3416 /* Place block on done queue */
3417 list_add_tail(&sp->list, done_q);
3420 * If we get here we have a real problem!
3423 "qla1280: ISP invalid handle\n");
3428 case MBA_BUS_RESET: /* SCSI Bus Reset */
3429 ha->flags.reset_marker = 1;
3430 index = mailbox[6] & BIT_0;
3431 ha->bus_settings[index].reset_marker = 1;
3433 printk(KERN_DEBUG "qla1280_isr(): index %i "
3434 "asynchronous BUS_RESET\n", index);
3437 case MBA_SYSTEM_ERR: /* System Error */
3439 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3440 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3444 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3446 "qla1280: ISP Request Transfer Error\n");
3449 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3451 "qla1280: ISP Response Transfer Error\n");
3454 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3455 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3458 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3460 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3463 case MBA_DEVICE_RESET: /* Bus Device Reset */
3464 printk(KERN_INFO "qla1280_isr(): asynchronous "
3465 "BUS_DEVICE_RESET\n");
3467 ha->flags.reset_marker = 1;
3468 index = mailbox[6] & BIT_0;
3469 ha->bus_settings[index].reset_marker = 1;
3472 case MBA_BUS_MODE_CHANGE:
3474 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3478 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3479 if (mailbox[0] < MBA_ASYNC_EVENT) {
3481 memcpy((uint16_t *) ha->mailbox_out, wptr,
3482 MAILBOX_REGISTER_COUNT *
3485 if(ha->mailbox_wait != NULL)
3486 complete(ha->mailbox_wait);
3491 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3495 * We will receive interrupts during mailbox testing prior to
3496 * the card being marked online, hence the double check.
3498 if (!(ha->flags.online && !ha->mailbox_wait)) {
3499 dprintk(2, "qla1280_isr: Response pointer Error\n");
3503 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3506 while (ha->rsp_ring_index != mailbox[5]) {
3507 pkt = ha->response_ring_ptr;
3509 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3510 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3511 dprintk(5,"qla1280_isr: response packet data\n");
3512 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3514 if (pkt->entry_type == STATUS_TYPE) {
3515 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3516 || pkt->comp_status || pkt->entry_status) {
3517 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3518 "0x%x mailbox[5] = 0x%x, comp_status "
3519 "= 0x%x, scsi_status = 0x%x\n",
3520 ha->rsp_ring_index, mailbox[5],
3521 le16_to_cpu(pkt->comp_status),
3522 le16_to_cpu(pkt->scsi_status));
3525 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3526 "0x%x, mailbox[5] = 0x%x\n",
3527 ha->rsp_ring_index, mailbox[5]);
3528 dprintk(2, "qla1280_isr: response packet data\n");
3529 qla1280_dump_buffer(2, (char *)pkt,
3530 RESPONSE_ENTRY_SIZE);
3533 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3534 dprintk(2, "status: Cmd %p, handle %i\n",
3535 ha->outstanding_cmds[pkt->handle]->cmd,
3537 if (pkt->entry_type == STATUS_TYPE)
3538 qla1280_status_entry(ha, pkt, done_q);
3540 qla1280_error_entry(ha, pkt, done_q);
3541 /* Adjust ring index. */
3542 ha->rsp_ring_index++;
3543 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3544 ha->rsp_ring_index = 0;
3545 ha->response_ring_ptr = ha->response_ring;
3547 ha->response_ring_ptr++;
3548 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3553 LEAVE("qla1280_isr");
3558 * Processes asynchronous reset.
3561 * ha = adapter block pointer.
3564 qla1280_rst_aen(struct scsi_qla_host *ha)
3568 ENTER("qla1280_rst_aen");
3570 if (ha->flags.online && !ha->flags.reset_active &&
3571 !ha->flags.abort_isp_active) {
3572 ha->flags.reset_active = 1;
3573 while (ha->flags.reset_marker) {
3574 /* Issue marker command. */
3575 ha->flags.reset_marker = 0;
3576 for (bus = 0; bus < ha->ports &&
3577 !ha->flags.reset_marker; bus++) {
3578 if (ha->bus_settings[bus].reset_marker) {
3579 ha->bus_settings[bus].reset_marker = 0;
3580 qla1280_marker(ha, bus, 0, 0,
3587 LEAVE("qla1280_rst_aen");
3592 * qla1280_status_entry
3593 * Processes received ISP status entry.
3596 * ha = adapter block pointer.
3597 * pkt = entry pointer.
3598 * done_q = done queue.
3601 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3602 struct list_head *done_q)
3606 struct scsi_cmnd *cmd;
3607 uint32_t handle = le32_to_cpu(pkt->handle);
3608 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3609 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3611 ENTER("qla1280_status_entry");
3613 /* Validate handle. */
3614 if (handle < MAX_OUTSTANDING_COMMANDS)
3615 sp = ha->outstanding_cmds[handle];
3620 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3624 /* Free outstanding command slot. */
3625 ha->outstanding_cmds[handle] = NULL;
3629 if (comp_status || scsi_status) {
3630 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3631 "0x%x, handle = 0x%x\n", comp_status,
3632 scsi_status, handle);
3635 /* Target busy or queue full */
3636 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3637 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3638 CMD_RESULT(cmd) = scsi_status & 0xff;
3641 /* Save ISP completion status */
3642 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3644 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3645 if (comp_status != CS_ARS_FAILED) {
3646 uint16_t req_sense_length =
3647 le16_to_cpu(pkt->req_sense_length);
3648 if (req_sense_length < CMD_SNSLEN(cmd))
3649 sense_sz = req_sense_length;
3652 * scsi_cmnd->sense_buffer is
3653 * 64 bytes, why only copy 63?
3654 * This looks wrong! /Jes
3656 sense_sz = CMD_SNSLEN(cmd) - 1;
3658 memcpy(cmd->sense_buffer,
3659 &pkt->req_sense_data, sense_sz);
3662 memset(cmd->sense_buffer + sense_sz, 0,
3663 SCSI_SENSE_BUFFERSIZE - sense_sz);
3665 dprintk(2, "qla1280_status_entry: Check "
3666 "condition Sense data, b %i, t %i, "
3667 "l %i\n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3670 qla1280_dump_buffer(2,
3671 (char *)cmd->sense_buffer,
3676 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3678 /* Place command on done queue. */
3679 list_add_tail(&sp->list, done_q);
3681 LEAVE("qla1280_status_entry");
3685 * qla1280_error_entry
3686 * Processes error entry.
3689 * ha = adapter block pointer.
3690 * pkt = entry pointer.
3691 * done_q = done queue.
3694 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3695 struct list_head *done_q)
3698 uint32_t handle = le32_to_cpu(pkt->handle);
3700 ENTER("qla1280_error_entry");
3702 if (pkt->entry_status & BIT_3)
3703 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3704 else if (pkt->entry_status & BIT_2)
3705 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3706 else if (pkt->entry_status & BIT_1)
3707 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3709 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3711 /* Validate handle. */
3712 if (handle < MAX_OUTSTANDING_COMMANDS)
3713 sp = ha->outstanding_cmds[handle];
3718 /* Free outstanding command slot. */
3719 ha->outstanding_cmds[handle] = NULL;
3721 /* Bad payload or header */
3722 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3723 /* Bad payload or header, set error status. */
3724 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3725 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3726 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3727 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3729 /* Set error status. */
3730 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3733 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3735 /* Place command on done queue. */
3736 list_add_tail(&sp->list, done_q);
3738 #ifdef QLA_64BIT_PTR
3739 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3740 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3744 LEAVE("qla1280_error_entry");
3749 * Resets ISP and aborts all outstanding commands.
3752 * ha = adapter block pointer.
3758 qla1280_abort_isp(struct scsi_qla_host *ha)
3760 struct device_reg __iomem *reg = ha->iobase;
3766 ENTER("qla1280_abort_isp");
3768 if (ha->flags.abort_isp_active || !ha->flags.online)
3771 ha->flags.abort_isp_active = 1;
3773 /* Disable ISP interrupts. */
3774 qla1280_disable_intrs(ha);
3775 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3776 RD_REG_WORD(®->id_l);
3778 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3780 /* Dequeue all commands in outstanding command list. */
3781 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3782 struct scsi_cmnd *cmd;
3783 sp = ha->outstanding_cmds[cnt];
3786 CMD_RESULT(cmd) = DID_RESET << 16;
3787 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
3788 ha->outstanding_cmds[cnt] = NULL;
3789 list_add_tail(&sp->list, &ha->done_q);
3795 status = qla1280_load_firmware(ha);
3799 /* Setup adapter based on NVRAM parameters. */
3800 qla1280_nvram_config (ha);
3802 status = qla1280_init_rings(ha);
3806 /* Issue SCSI reset. */
3807 for (bus = 0; bus < ha->ports; bus++)
3808 qla1280_bus_reset(ha, bus);
3810 ha->flags.abort_isp_active = 0;
3814 "qla1280: ISP error recovery failed, board disabled");
3815 qla1280_reset_adapter(ha);
3816 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3819 LEAVE("qla1280_abort_isp");
3825 * qla1280_debounce_register
3826 * Debounce register.
3829 * port = register address.
3835 qla1280_debounce_register(volatile u16 __iomem * addr)
3840 ret = RD_REG_WORD(addr);
3841 ret2 = RD_REG_WORD(addr);
3848 ret = RD_REG_WORD(addr);
3849 ret2 = RD_REG_WORD(addr);
3850 } while (ret != ret2);
3856 /************************************************************************
3857 * qla1280_check_for_dead_scsi_bus *
3859 * This routine checks for a dead SCSI bus *
3860 ************************************************************************/
3861 #define SET_SXP_BANK 0x0100
3862 #define SCSI_PHASE_INVALID 0x87FF
3864 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3866 uint16_t config_reg, scsi_control;
3867 struct device_reg __iomem *reg = ha->iobase;
3869 if (ha->bus_settings[bus].scsi_bus_dead) {
3870 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3871 config_reg = RD_REG_WORD(®->cfg_1);
3872 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
3873 scsi_control = RD_REG_WORD(®->scsiControlPins);
3874 WRT_REG_WORD(®->cfg_1, config_reg);
3875 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
3877 if (scsi_control == SCSI_PHASE_INVALID) {
3878 ha->bus_settings[bus].scsi_bus_dead = 1;
3879 return 1; /* bus is dead */
3881 ha->bus_settings[bus].scsi_bus_dead = 0;
3882 ha->bus_settings[bus].failed_reset_count = 0;
3885 return 0; /* bus is not dead */
3889 qla1280_get_target_parameters(struct scsi_qla_host *ha,
3890 struct scsi_device *device)
3892 uint16_t mb[MAILBOX_REGISTER_COUNT];
3893 int bus, target, lun;
3895 bus = device->channel;
3896 target = device->id;
3900 mb[0] = MBC_GET_TARGET_PARAMETERS;
3901 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3903 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3906 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3909 printk(KERN_CONT " Sync: period %d, offset %d",
3910 (mb[3] & 0xff), (mb[3] >> 8));
3912 printk(KERN_CONT ", Wide");
3913 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3914 printk(KERN_CONT ", DT");
3916 printk(KERN_CONT " Async");
3918 if (device->simple_tags)
3919 printk(KERN_CONT ", Tagged queuing: depth %d", device->queue_depth);
3920 printk(KERN_CONT "\n");
3926 __qla1280_dump_buffer(char *b, int size)
3931 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3932 "Bh Ch Dh Eh Fh\n");
3933 printk(KERN_DEBUG "---------------------------------------------"
3934 "------------------\n");
3936 for (cnt = 0; cnt < size;) {
3939 printk("0x%02x", c);
3950 /**************************************************************************
3951 * ql1280_print_scsi_cmd
3953 **************************************************************************/
3955 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
3957 struct scsi_qla_host *ha;
3958 struct Scsi_Host *host = CMD_HOST(cmd);
3960 /* struct scatterlist *sg; */
3963 ha = (struct scsi_qla_host *)host->hostdata;
3965 sp = (struct srb *)CMD_SP(cmd);
3966 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
3967 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
3968 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
3971 for (i = 0; i < cmd->cmd_len; i++) {
3972 printk("0x%02x ", cmd->cmnd[i]);
3974 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
3975 printk(" request buffer=0x%p, request buffer len=0x%x\n",
3976 scsi_sglist(cmd), scsi_bufflen(cmd));
3979 sg = (struct scatterlist *) cmd->request_buffer;
3980 printk(" SG buffer: \n");
3981 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
3983 printk(" tag=%d, transfersize=0x%x \n",
3984 cmd->tag, cmd->transfersize);
3985 printk(" SP=0x%p\n", CMD_SP(cmd));
3986 printk(" underflow size = 0x%x, direction=0x%x\n",
3987 cmd->underflow, cmd->sc_data_direction);
3990 /**************************************************************************
3991 * ql1280_dump_device
3993 **************************************************************************/
3995 ql1280_dump_device(struct scsi_qla_host *ha)
3998 struct scsi_cmnd *cp;
4002 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4004 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4005 if ((sp = ha->outstanding_cmds[i]) == NULL)
4007 if ((cp = sp->cmd) == NULL)
4009 qla1280_print_scsi_cmd(1, cp);
4024 struct setup_tokens {
4029 static struct setup_tokens setup_token[] __initdata =
4031 { "nvram", TOKEN_NVRAM },
4032 { "sync", TOKEN_SYNC },
4033 { "wide", TOKEN_WIDE },
4034 { "ppr", TOKEN_PPR },
4035 { "verbose", TOKEN_VERBOSE },
4036 { "debug", TOKEN_DEBUG },
4040 /**************************************************************************
4043 * Handle boot parameters. This really needs to be changed so one
4044 * can specify per adapter parameters.
4045 **************************************************************************/
4047 qla1280_setup(char *s)
4055 while (cp && (ptr = strchr(cp, ':'))) {
4057 if (!strcmp(ptr, "yes")) {
4060 } else if (!strcmp(ptr, "no")) {
4064 val = simple_strtoul(ptr, &ptr, 0);
4066 switch ((toke = qla1280_get_token(cp))) {
4069 driver_setup.no_nvram = 1;
4073 driver_setup.no_sync = 1;
4074 else if (val != 0x10000)
4075 driver_setup.sync_mask = val;
4079 driver_setup.no_wide = 1;
4080 else if (val != 0x10000)
4081 driver_setup.wide_mask = val;
4085 driver_setup.no_ppr = 1;
4086 else if (val != 0x10000)
4087 driver_setup.ppr_mask = val;
4090 qla1280_verbose = val;
4093 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4097 cp = strchr(ptr, ';');
4109 qla1280_get_token(char *str)
4115 sep = strchr(str, ':');
4118 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
4119 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4120 ret = setup_token[i].val;
4130 static struct scsi_host_template qla1280_driver_template = {
4131 .module = THIS_MODULE,
4132 .proc_name = "qla1280",
4133 .name = "Qlogic ISP 1280/12160",
4134 .info = qla1280_info,
4135 .slave_configure = qla1280_slave_configure,
4136 .queuecommand = qla1280_queuecommand,
4137 .eh_abort_handler = qla1280_eh_abort,
4138 .eh_device_reset_handler= qla1280_eh_device_reset,
4139 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4140 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4141 .bios_param = qla1280_biosparam,
4142 .can_queue = MAX_OUTSTANDING_COMMANDS,
4144 .sg_tablesize = SG_ALL,
4149 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4151 int devnum = id->driver_data;
4152 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4153 struct Scsi_Host *host;
4154 struct scsi_qla_host *ha;
4155 int error = -ENODEV;
4157 /* Bypass all AMI SUBSYS VENDOR IDs */
4158 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4160 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4164 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4165 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4167 if (pci_enable_device(pdev)) {
4169 "qla1280: Failed to enabled pci device, aborting.\n");
4173 pci_set_master(pdev);
4176 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4179 "qla1280: Failed to register host, aborting.\n");
4180 goto error_disable_device;
4183 ha = (struct scsi_qla_host *)host->hostdata;
4184 memset(ha, 0, sizeof(struct scsi_qla_host));
4187 ha->devnum = devnum; /* specifies microcode load address */
4189 #ifdef QLA_64BIT_PTR
4190 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
4191 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4192 printk(KERN_WARNING "scsi(%li): Unable to set a "
4193 "suitable DMA mask - aborting\n", ha->host_no);
4195 goto error_put_host;
4198 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4201 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4202 printk(KERN_WARNING "scsi(%li): Unable to set a "
4203 "suitable DMA mask - aborting\n", ha->host_no);
4205 goto error_put_host;
4209 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
4210 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4211 &ha->request_dma, GFP_KERNEL);
4212 if (!ha->request_ring) {
4213 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4214 goto error_put_host;
4217 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
4218 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4219 &ha->response_dma, GFP_KERNEL);
4220 if (!ha->response_ring) {
4221 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4222 goto error_free_request_ring;
4225 ha->ports = bdp->numPorts;
4228 ha->host_no = host->host_no;
4230 host->irq = pdev->irq;
4231 host->max_channel = bdp->numPorts - 1;
4232 host->max_lun = MAX_LUNS - 1;
4233 host->max_id = MAX_TARGETS;
4234 host->max_sectors = 1024;
4235 host->unique_id = host->host_no;
4239 #if MEMORY_MAPPED_IO
4240 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
4242 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4243 goto error_free_response_ring;
4246 host->base = (unsigned long)ha->mmpbase;
4247 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4249 host->io_port = pci_resource_start(ha->pdev, 0);
4250 if (!request_region(host->io_port, 0xff, "qla1280")) {
4251 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4252 "0x%04lx-0x%04lx - already in use\n",
4253 host->io_port, host->io_port + 0xff);
4254 goto error_free_response_ring;
4257 ha->iobase = (struct device_reg *)host->io_port;
4260 INIT_LIST_HEAD(&ha->done_q);
4262 /* Disable ISP interrupts. */
4263 qla1280_disable_intrs(ha);
4265 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
4267 printk("qla1280 : Failed to reserve interrupt %d already "
4268 "in use\n", pdev->irq);
4269 goto error_release_region;
4272 /* load the F/W, read paramaters, and init the H/W */
4273 if (qla1280_initialize_adapter(ha)) {
4274 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4275 goto error_free_irq;
4278 /* set our host ID (need to do something about our two IDs) */
4279 host->this_id = ha->bus_settings[0].id;
4281 pci_set_drvdata(pdev, host);
4283 error = scsi_add_host(host, &pdev->dev);
4285 goto error_disable_adapter;
4286 scsi_scan_host(host);
4290 error_disable_adapter:
4291 qla1280_disable_intrs(ha);
4293 free_irq(pdev->irq, ha);
4294 error_release_region:
4295 #if MEMORY_MAPPED_IO
4296 iounmap(ha->mmpbase);
4298 release_region(host->io_port, 0xff);
4300 error_free_response_ring:
4301 dma_free_coherent(&ha->pdev->dev,
4302 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4303 ha->response_ring, ha->response_dma);
4304 error_free_request_ring:
4305 dma_free_coherent(&ha->pdev->dev,
4306 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4307 ha->request_ring, ha->request_dma);
4309 scsi_host_put(host);
4310 error_disable_device:
4311 pci_disable_device(pdev);
4318 qla1280_remove_one(struct pci_dev *pdev)
4320 struct Scsi_Host *host = pci_get_drvdata(pdev);
4321 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4323 scsi_remove_host(host);
4325 qla1280_disable_intrs(ha);
4327 free_irq(pdev->irq, ha);
4329 #if MEMORY_MAPPED_IO
4330 iounmap(ha->mmpbase);
4332 release_region(host->io_port, 0xff);
4335 dma_free_coherent(&ha->pdev->dev,
4336 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4337 ha->request_ring, ha->request_dma);
4338 dma_free_coherent(&ha->pdev->dev,
4339 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4340 ha->response_ring, ha->response_dma);
4342 pci_disable_device(pdev);
4344 scsi_host_put(host);
4347 static struct pci_driver qla1280_pci_driver = {
4349 .id_table = qla1280_pci_tbl,
4350 .probe = qla1280_probe_one,
4351 .remove = qla1280_remove_one,
4357 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4359 "qla1280: struct srb too big, aborting\n");
4365 * If we are called as a module, the qla1280 pointer may not be null
4366 * and it would point to our bootup string, just like on the lilo
4367 * command line. IF not NULL, then process this config string with
4371 * To add options at boot time add a line to your lilo.conf file like:
4372 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4373 * which will result in the first four devices on the first two
4374 * controllers being set to a tagged queue depth of 32.
4377 qla1280_setup(qla1280);
4380 return pci_register_driver(&qla1280_pci_driver);
4388 pci_unregister_driver(&qla1280_pci_driver);
4389 /* release any allocated firmware images */
4390 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4391 release_firmware(qla1280_fw_tbl[i].fw);
4392 qla1280_fw_tbl[i].fw = NULL;
4396 module_init(qla1280_init);
4397 module_exit(qla1280_exit);
4399 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4400 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4401 MODULE_LICENSE("GPL");
4402 MODULE_FIRMWARE("qlogic/1040.bin");
4403 MODULE_FIRMWARE("qlogic/1280.bin");
4404 MODULE_FIRMWARE("qlogic/12160.bin");
4405 MODULE_VERSION(QLA1280_VERSION);
4408 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4409 * Emacs will notice this stuff at the end of the file and automatically
4410 * adjust the settings for this buffer only. This must remain at the end
4412 * ---------------------------------------------------------------------------