1 /******************************************************************************
2 * QLOGIC LINUX SOFTWARE
4 * QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver
5 * Copyright (C) 2000 Qlogic Corporation (www.qlogic.com)
6 * Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc.
7 * Copyright (C) 2003-2004 Christoph Hellwig
9 * This program is free software; you can redistribute it and/or modify it
10 * under the terms of the GNU General Public License as published by the
11 * Free Software Foundation; either version 2, or (at your option) any
14 * This program is distributed in the hope that it will be useful, but
15 * WITHOUT ANY WARRANTY; without even the implied warranty of
16 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
17 * General Public License for more details.
19 ******************************************************************************/
20 #define QLA1280_VERSION "3.27.1"
21 /*****************************************************************************
23 Rev 3.27.1, February 8, 2010, Michael Reed
24 - Retain firmware image for error recovery.
25 Rev 3.27, February 10, 2009, Michael Reed
26 - General code cleanup.
27 - Improve error recovery.
28 Rev 3.26, January 16, 2006 Jes Sorensen
29 - Ditch all < 2.6 support
30 Rev 3.25.1, February 10, 2005 Christoph Hellwig
31 - use pci_map_single to map non-S/G requests
32 - remove qla1280_proc_info
33 Rev 3.25, September 28, 2004, Christoph Hellwig
34 - add support for ISP1020/1040
35 - don't include "scsi.h" anymore for 2.6.x
36 Rev 3.24.4 June 7, 2004 Christoph Hellwig
37 - restructure firmware loading, cleanup initialization code
38 - prepare support for ISP1020/1040 chips
39 Rev 3.24.3 January 19, 2004, Jes Sorensen
40 - Handle PCI DMA mask settings correctly
41 - Correct order of error handling in probe_one, free_irq should not
42 be called if request_irq failed
43 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
44 - Big endian fixes (James)
45 - Remove bogus IOCB content on zero data transfer commands (Andrew)
46 Rev 3.24.1 January 5, 2004, Jes Sorensen
47 - Initialize completion queue to avoid OOPS on probe
48 - Handle interrupts during mailbox testing
49 Rev 3.24 November 17, 2003, Christoph Hellwig
50 - use struct list_head for completion queue
51 - avoid old Scsi_FOO typedefs
52 - cleanup 2.4 compat glue a bit
53 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
54 - make initialization for memory mapped vs port I/O more similar
55 - remove broken pci config space manipulation
57 - this is an almost perfect 2.6 scsi driver now! ;)
58 Rev 3.23.39 December 17, 2003, Jes Sorensen
59 - Delete completion queue from srb if mailbox command failed to
60 to avoid qla1280_done completeting qla1280_error_action's
62 - Reduce arguments for qla1280_done
63 Rev 3.23.38 October 18, 2003, Christoph Hellwig
64 - Convert to new-style hotplugable driver for 2.6
65 - Fix missing scsi_unregister/scsi_host_put on HBA removal
66 - Kill some more cruft
67 Rev 3.23.37 October 1, 2003, Jes Sorensen
68 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
70 - Clean up locking in probe path
71 Rev 3.23.36 October 1, 2003, Christoph Hellwig
72 - queuecommand only ever receives new commands - clear flags
73 - Reintegrate lost fixes from Linux 2.5
74 Rev 3.23.35 August 14, 2003, Jes Sorensen
76 Rev 3.23.34 July 23, 2003, Jes Sorensen
77 - Remove pointless TRUE/FALSE macros
78 - Clean up vchan handling
79 Rev 3.23.33 July 3, 2003, Jes Sorensen
80 - Don't define register access macros before define determining MMIO.
81 This just happened to work out on ia64 but not elsewhere.
82 - Don't try and read from the card while it is in reset as
83 it won't respond and causes an MCA
84 Rev 3.23.32 June 23, 2003, Jes Sorensen
85 - Basic support for boot time arguments
86 Rev 3.23.31 June 8, 2003, Jes Sorensen
87 - Reduce boot time messages
88 Rev 3.23.30 June 6, 2003, Jes Sorensen
89 - Do not enable sync/wide/ppr before it has been determined
90 that the target device actually supports it
91 - Enable DMA arbitration for multi channel controllers
92 Rev 3.23.29 June 3, 2003, Jes Sorensen
94 Rev 3.23.28 June 3, 2003, Jes Sorensen
95 - Eliminate duplicate marker commands on bus resets
96 - Handle outstanding commands appropriately on bus/device resets
97 Rev 3.23.27 May 28, 2003, Jes Sorensen
98 - Remove bogus input queue code, let the Linux SCSI layer do the work
99 - Clean up NVRAM handling, only read it once from the card
100 - Add a number of missing default nvram parameters
101 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
102 - Use completion queue for mailbox commands instead of busy wait
103 Rev 3.23.25 Beta May 27, 2003, James Bottomley
104 - Migrate to use new error handling code
105 Rev 3.23.24 Beta May 21, 2003, James Bottomley
107 - Cleanup data direction code
108 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
109 - Switch to using MMIO instead of PIO
110 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
111 - Fix PCI parity problem with 12160 during reset.
112 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
113 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
114 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
115 - Remove < 2.4.x support
116 - Introduce HOST_LOCK to make the spin lock changes portable.
117 - Remove a bunch of idiotic and unnecessary typedef's
118 - Kill all leftovers of target-mode support which never worked anyway
119 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
120 - Do qla1280_pci_config() before calling request_irq() and
122 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
124 - Hand correct arguments to free_irq() in case of failure
125 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
126 - Run source through Lindent and clean up the output
127 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
128 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
129 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
130 - Rely on mailbox commands generating interrupts - do not
131 run qla1280_isr() from ql1280_mailbox_command()
132 - Remove device_reg_t
133 - Integrate ql12160_set_target_parameters() with 1280 version
134 - Make qla1280_setup() non static
135 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
136 sent to the card - this command pauses the firmware!!!
137 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
138 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
139 - Remove a pile of pointless and confusing (srb_t **) and
140 (scsi_lu_t *) typecasts
141 - Explicit mark that we do not use the new error handling (for now)
142 - Remove scsi_qla_host_t and use 'struct' instead
143 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
144 pci_64bit_slot flags which weren't used for anything anyway
145 - Grab host->host_lock while calling qla1280_isr() from abort()
146 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
147 do not need to save/restore flags in the interrupt handler
148 - Enable interrupts early (before any mailbox access) in preparation
149 for cleaning up the mailbox handling
150 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
151 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
152 it with proper use of dprintk().
153 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
154 a debug level argument to determine if data is to be printed
155 - Add KERN_* info to printk()
156 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
157 - Significant cosmetic cleanups
158 - Change debug code to use dprintk() and remove #if mess
159 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
160 - More cosmetic cleanups, fix places treating return as function
161 - use cpu_relax() in qla1280_debounce_register()
162 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
163 - Make it compile under 2.5.5
164 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
165 - Do no typecast short * to long * in QL1280BoardTbl, this
166 broke miserably on big endian boxes
167 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
168 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
169 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
170 unsigned int to match the types from struct scsi_cmnd
171 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
172 - Remove bogus timer_t typedef from qla1280.h
173 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
174 for PCI_ values, call pci_set_master()
175 - Fix memleak of qla1280_buffer on module unload
176 - Only compile module parsing code #ifdef MODULE - should be
177 changed to use individual MODULE_PARM's later
178 - Remove dummy_buffer that was never modified nor printed
179 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
180 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
181 - Remove \r from print statements, this is Linux, not DOS
182 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
184 - Remove C++ compile hack in header file as Linux driver are not
185 supposed to be compiled as C++
186 - Kill MS_64BITS macro as it makes the code more readable
187 - Remove unnecessary flags.in_interrupts bit
188 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
189 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
190 - Check whether the interrupt was generated by the QLA1280 before
192 - qla1280_status_entry(): Only zero out part of sense_buffer that
193 is not being copied into
194 - Remove more superflouous typecasts
195 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
196 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
197 - Don't walk the entire list in qla1280_putq_t() just to directly
198 grab the pointer to the last element afterwards
199 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
200 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
201 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
202 - Set dev->max_sectors to 1024
203 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
204 - Provide compat macros for pci_enable_device(), pci_find_subsys()
205 and scsi_set_pci_device()
206 - Call scsi_set_pci_device() for all devices
207 - Reduce size of kernel version dependent device probe code
208 - Move duplicate probe/init code to separate function
209 - Handle error if qla1280_mem_alloc() fails
210 - Kill OFFSET() macro and use Linux's PCI definitions instead
211 - Kill private structure defining PCI config space (struct config_reg)
212 - Only allocate I/O port region if not in MMIO mode
213 - Remove duplicate (unused) sanity check of sife of srb_t
214 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
215 - Change home-brew memset() implementations to use memset()
216 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
217 port directly is not legal under Linux.
218 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
219 - Remove pre 2.2 kernel support
220 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
221 - Fix MMIO access to use readl/writel instead of directly
222 dereferencing pointers
223 - Nuke MSDOS debugging code
224 - Change true/false data types to int from uint8_t
225 - Use int for counters instead of uint8_t etc.
226 - Clean up size & byte order conversion macro usage
227 Rev 3.23 Beta January 11, 2001 BN Qlogic
228 - Added check of device_id when handling non
229 QLA12160s during detect().
230 Rev 3.22 Beta January 5, 2001 BN Qlogic
231 - Changed queue_task() to schedule_task()
232 for kernels 2.4.0 and higher.
233 Note: 2.4.0-testxx kernels released prior to
234 the actual 2.4.0 kernel release on January 2001
235 will get compile/link errors with schedule_task().
236 Please update your kernel to released 2.4.0 level,
237 or comment lines in this file flagged with 3.22
238 to resolve compile/link error of schedule_task().
239 - Added -DCONFIG_SMP in addition to -D__SMP__
240 in Makefile for 2.4.0 builds of driver as module.
241 Rev 3.21 Beta January 4, 2001 BN Qlogic
242 - Changed criteria of 64/32 Bit mode of HBA
243 operation according to BITS_PER_LONG rather
244 than HBA's NVRAM setting of >4Gig memory bit;
245 so that the HBA auto-configures without the need
246 to setup each system individually.
247 Rev 3.20 Beta December 5, 2000 BN Qlogic
248 - Added priority handling to IA-64 onboard SCSI
249 ISP12160 chip for kernels greater than 2.3.18.
250 - Added irqrestore for qla1280_intr_handler.
251 - Enabled /proc/scsi/qla1280 interface.
252 - Clear /proc/scsi/qla1280 counters in detect().
253 Rev 3.19 Beta October 13, 2000 BN Qlogic
254 - Declare driver_template for new kernel
255 (2.4.0 and greater) scsi initialization scheme.
256 - Update /proc/scsi entry for 2.3.18 kernels and
258 Rev 3.18 Beta October 10, 2000 BN Qlogic
259 - Changed scan order of adapters to map
260 the QLA12160 followed by the QLA1280.
261 Rev 3.17 Beta September 18, 2000 BN Qlogic
262 - Removed warnings for 32 bit 2.4.x compiles
263 - Corrected declared size for request and response
264 DMA addresses that are kept in each ha
265 Rev. 3.16 Beta August 25, 2000 BN Qlogic
266 - Corrected 64 bit addressing issue on IA-64
267 where the upper 32 bits were not properly
268 passed to the RISC engine.
269 Rev. 3.15 Beta August 22, 2000 BN Qlogic
270 - Modified qla1280_setup_chip to properly load
271 ISP firmware for greater that 4 Gig memory on IA-64
272 Rev. 3.14 Beta August 16, 2000 BN Qlogic
273 - Added setting of dma_mask to full 64 bit
274 if flags.enable_64bit_addressing is set in NVRAM
275 Rev. 3.13 Beta August 16, 2000 BN Qlogic
276 - Use new PCI DMA mapping APIs for 2.4.x kernel
277 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
278 - Added check of pci_enable_device to detect() for 2.3.x
279 - Use pci_resource_start() instead of
280 pdev->resource[0].start in detect() for 2.3.x
281 - Updated driver version
282 Rev. 3.11 July 14, 2000 BN Qlogic
283 - Updated SCSI Firmware to following versions:
286 - Updated driver version to 3.11
287 Rev. 3.10 June 23, 2000 BN Qlogic
288 - Added filtering of AMI SubSys Vendor ID devices
290 - DEBUG_QLA1280 undefined and new version BN Qlogic
291 Rev. 3.08b May 9, 2000 MD Dell
292 - Added logic to check against AMI subsystem vendor ID
293 Rev. 3.08 May 4, 2000 DG Qlogic
294 - Added logic to check for PCI subsystem ID.
295 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
296 - Updated SCSI Firmware to following versions:
299 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
300 - Internal revision; not released
301 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
302 - Edit correction for virt_to_bus and PROC.
303 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
304 - Merge changes from ia64 port.
305 Rev. 3.03 Mar 28, 2000 BN Qlogic
306 - Increase version to reflect new code drop with compile fix
307 of issue with inclusion of linux/spinlock for 2.3 kernels
308 Rev. 3.02 Mar 15, 2000 BN Qlogic
309 - Merge qla1280_proc_info from 2.10 code base
310 Rev. 3.01 Feb 10, 2000 BN Qlogic
311 - Corrected code to compile on a 2.2.x kernel.
312 Rev. 3.00 Jan 17, 2000 DG Qlogic
313 - Added 64-bit support.
314 Rev. 2.07 Nov 9, 1999 DG Qlogic
315 - Added new routine to set target parameters for ISP12160.
316 Rev. 2.06 Sept 10, 1999 DG Qlogic
317 - Added support for ISP12160 Ultra 3 chip.
318 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
319 - Modified code to remove errors generated when compiling with
320 Cygnus IA64 Compiler.
321 - Changed conversion of pointers to unsigned longs instead of integers.
322 - Changed type of I/O port variables from uint32_t to unsigned long.
323 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
324 - Changed sprintf and printk format specifiers for pointers to %p.
325 - Changed some int to long type casts where needed in sprintf & printk.
326 - Added l modifiers to sprintf and printk format specifiers for longs.
327 - Removed unused local variables.
328 Rev. 1.20 June 8, 1999 DG, Qlogic
329 Changes to support RedHat release 6.0 (kernel 2.2.5).
330 - Added SCSI exclusive access lock (io_request_lock) when accessing
332 - Added changes for the new LINUX interface template. Some new error
333 handling routines have been added to the template, but for now we
334 will use the old ones.
335 - Initial Beta Release.
336 *****************************************************************************/
339 #include <linux/module.h>
341 #include <linux/types.h>
342 #include <linux/string.h>
343 #include <linux/errno.h>
344 #include <linux/kernel.h>
345 #include <linux/ioport.h>
346 #include <linux/delay.h>
347 #include <linux/timer.h>
348 #include <linux/pci.h>
349 #include <linux/proc_fs.h>
350 #include <linux/stat.h>
351 #include <linux/pci_ids.h>
352 #include <linux/interrupt.h>
353 #include <linux/init.h>
354 #include <linux/dma-mapping.h>
355 #include <linux/firmware.h>
359 #include <asm/byteorder.h>
360 #include <asm/processor.h>
361 #include <asm/types.h>
363 #include <scsi/scsi.h>
364 #include <scsi/scsi_cmnd.h>
365 #include <scsi/scsi_device.h>
366 #include <scsi/scsi_host.h>
367 #include <scsi/scsi_tcq.h>
369 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
370 #include <asm/sn/io.h>
375 * Compile time Options:
376 * 0 - Disable and 1 - Enable
378 #define DEBUG_QLA1280_INTR 0
379 #define DEBUG_PRINT_NVRAM 0
380 #define DEBUG_QLA1280 0
382 #define MEMORY_MAPPED_IO 1
386 #ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
387 #define QLA_64BIT_PTR 1
390 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */
392 #if defined(__ia64__) && !defined(ia64_platform_is)
393 #define ia64_platform_is(foo) (!strcmp(x, platform_name))
397 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
398 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
399 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
400 #define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
401 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
404 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
405 static void qla1280_remove_one(struct pci_dev *);
408 * QLogic Driver Support Function Prototypes.
410 static void qla1280_done(struct scsi_qla_host *);
411 static int qla1280_get_token(char *);
412 static int qla1280_setup(char *s) __init;
415 * QLogic ISP1280 Hardware Support Function Prototypes.
417 static int qla1280_load_firmware(struct scsi_qla_host *);
418 static int qla1280_init_rings(struct scsi_qla_host *);
419 static int qla1280_nvram_config(struct scsi_qla_host *);
420 static int qla1280_mailbox_command(struct scsi_qla_host *,
421 uint8_t, uint16_t *);
422 static int qla1280_bus_reset(struct scsi_qla_host *, int);
423 static int qla1280_device_reset(struct scsi_qla_host *, int, int);
424 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
425 static int qla1280_abort_isp(struct scsi_qla_host *);
427 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
429 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
431 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
432 static void qla1280_poll(struct scsi_qla_host *);
433 static void qla1280_reset_adapter(struct scsi_qla_host *);
434 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
435 static void qla1280_isp_cmd(struct scsi_qla_host *);
436 static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
437 static void qla1280_rst_aen(struct scsi_qla_host *);
438 static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
440 static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
442 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
443 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
444 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
445 static request_t *qla1280_req_pkt(struct scsi_qla_host *);
446 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
448 static void qla1280_get_target_parameters(struct scsi_qla_host *,
449 struct scsi_device *);
450 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
453 static struct qla_driver_setup driver_setup;
456 * convert scsi data direction to request_t control flags
458 static inline uint16_t
459 qla1280_data_direction(struct scsi_cmnd *cmnd)
461 switch(cmnd->sc_data_direction) {
462 case DMA_FROM_DEVICE:
466 case DMA_BIDIRECTIONAL:
467 return BIT_5 | BIT_6;
469 * We could BUG() on default here if one of the four cases aren't
470 * met, but then again if we receive something like that from the
471 * SCSI layer we have more serious problems. This shuts up GCC.
480 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
481 static void __qla1280_dump_buffer(char *, int);
486 * insmod needs to find the variable and make it point to something
489 static char *qla1280;
491 /* insmod qla1280 options=verbose" */
492 module_param(qla1280, charp, 0);
494 __setup("qla1280=", qla1280_setup);
499 * We use the scsi_pointer structure that's included with each scsi_command
500 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
501 * bigger than a scsi_pointer.
504 #define CMD_SP(Cmnd) &Cmnd->SCp
505 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
506 #define CMD_CDBP(Cmnd) Cmnd->cmnd
507 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
508 #define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
509 #define CMD_RESULT(Cmnd) Cmnd->result
510 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
511 #define CMD_REQUEST(Cmnd) Cmnd->request->cmd
513 #define CMD_HOST(Cmnd) Cmnd->device->host
514 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
515 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
516 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
519 /*****************************************/
520 /* ISP Boards supported by this driver */
521 /*****************************************/
524 char *name; /* Board ID String */
525 int numPorts; /* Number of SCSI ports */
526 int fw_index; /* index into qla1280_fw_tbl for firmware */
529 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
530 static struct pci_device_id qla1280_pci_tbl[] = {
531 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
532 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
533 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
534 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
535 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
536 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
537 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
538 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
539 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
540 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
541 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
542 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
545 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
547 DEFINE_MUTEX(qla1280_firmware_mutex);
551 const struct firmware *fw;
554 #define QL_NUM_FW_IMAGES 3
556 struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
557 {"qlogic/1040.bin", NULL}, /* image 0 */
558 {"qlogic/1280.bin", NULL}, /* image 1 */
559 {"qlogic/12160.bin", NULL}, /* image 2 */
562 /* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
563 static struct qla_boards ql1280_board_tbl[] = {
564 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
565 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
566 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
567 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
568 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
569 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
570 {.name = " ", .numPorts = 0, .fw_index = -1},
573 static int qla1280_verbose = 1;
576 static int ql_debug_level = 1;
577 #define dprintk(level, format, a...) \
578 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
579 #define qla1280_dump_buffer(level, buf, size) \
580 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
581 #define qla1280_print_scsi_cmd(level, cmd) \
582 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
584 #define ql_debug_level 0
585 #define dprintk(level, format, a...) do{}while(0)
586 #define qla1280_dump_buffer(a, b, c) do{}while(0)
587 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
590 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
591 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
592 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
593 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
596 static int qla1280_read_nvram(struct scsi_qla_host *ha)
603 ENTER("qla1280_read_nvram");
605 if (driver_setup.no_nvram)
608 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
610 wptr = (uint16_t *)&ha->nvram;
613 for (cnt = 0; cnt < 3; cnt++) {
614 *wptr = qla1280_get_nvram_word(ha, cnt);
615 chksum += *wptr & 0xff;
616 chksum += (*wptr >> 8) & 0xff;
620 if (nv->id0 != 'I' || nv->id1 != 'S' ||
621 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
622 dprintk(2, "Invalid nvram ID or version!\n");
625 for (; cnt < sizeof(struct nvram); cnt++) {
626 *wptr = qla1280_get_nvram_word(ha, cnt);
627 chksum += *wptr & 0xff;
628 chksum += (*wptr >> 8) & 0xff;
633 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
634 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
639 if (!driver_setup.no_nvram)
640 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
641 "validate NVRAM checksum, using default "
642 "settings\n", ha->host_no);
647 /* The firmware interface is, um, interesting, in that the
648 * actual firmware image on the chip is little endian, thus,
649 * the process of taking that image to the CPU would end up
650 * little endian. However, the firmware interface requires it
651 * to be read a word (two bytes) at a time.
653 * The net result of this would be that the word (and
654 * doubleword) quantites in the firmware would be correct, but
655 * the bytes would be pairwise reversed. Since most of the
656 * firmware quantites are, in fact, bytes, we do an extra
657 * le16_to_cpu() in the firmware read routine.
659 * The upshot of all this is that the bytes in the firmware
660 * are in the correct places, but the 16 and 32 bit quantites
661 * are still in little endian format. We fix that up below by
662 * doing extra reverses on them */
663 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
664 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
665 for(i = 0; i < MAX_BUSES; i++) {
666 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
667 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
669 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
670 LEAVE("qla1280_read_nvram");
675 /**************************************************************************
677 * Return a string describing the driver.
678 **************************************************************************/
680 qla1280_info(struct Scsi_Host *host)
682 static char qla1280_scsi_name_buffer[125];
684 struct scsi_qla_host *ha;
685 struct qla_boards *bdp;
687 bp = &qla1280_scsi_name_buffer[0];
688 ha = (struct scsi_qla_host *)host->hostdata;
689 bdp = &ql1280_board_tbl[ha->devnum];
690 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
693 "QLogic %s PCI to SCSI Host Adapter\n"
694 " Firmware version: %2d.%02d.%02d, Driver version %s",
695 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
700 /**************************************************************************
701 * qla1280_queuecommand
702 * Queue a command to the controller.
705 * The mid-level driver tries to ensures that queuecommand never gets invoked
706 * concurrently with itself or the interrupt handler (although the
707 * interrupt handler may call this routine as part of request-completion
708 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
709 * context which is a big NO! NO!.
710 **************************************************************************/
712 qla1280_queuecommand_lck(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
714 struct Scsi_Host *host = cmd->device->host;
715 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
716 struct srb *sp = (struct srb *)CMD_SP(cmd);
723 CMD_HANDLE(cmd) = (unsigned char *)NULL;
725 qla1280_print_scsi_cmd(5, cmd);
729 * Using 64 bit commands if the PCI bridge doesn't support it is a
730 * bit wasteful, however this should really only happen if one's
731 * PCI controller is completely broken, like the BCM1250. For
732 * sane hardware this is not an issue.
734 status = qla1280_64bit_start_scsi(ha, sp);
736 status = qla1280_32bit_start_scsi(ha, sp);
741 static DEF_SCSI_QCMD(qla1280_queuecommand)
751 static void qla1280_mailbox_timeout(struct timer_list *t)
753 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
754 struct device_reg __iomem *reg;
757 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
758 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
759 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
760 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
761 complete(ha->mailbox_wait);
765 _qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
766 struct completion *wait)
769 struct scsi_cmnd *cmd = sp->cmd;
771 spin_unlock_irq(ha->host->host_lock);
772 wait_for_completion_timeout(wait, 4*HZ);
773 spin_lock_irq(ha->host->host_lock);
775 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
777 (*cmd->scsi_done)(cmd);
783 qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
785 DECLARE_COMPLETION_ONSTACK(wait);
788 return _qla1280_wait_for_single_command(ha, sp, &wait);
792 qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
797 struct scsi_cmnd *cmd;
802 * Wait for all commands with the designated bus/target
803 * to be completed by the firmware
805 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
806 sp = ha->outstanding_cmds[cnt];
810 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
812 if (target >= 0 && SCSI_TCN_32(cmd) != target)
815 status = qla1280_wait_for_single_command(ha, sp);
816 if (status == FAILED)
823 /**************************************************************************
824 * qla1280_error_action
825 * The function will attempt to perform a specified error action and
826 * wait for the results (or time out).
829 * cmd = Linux SCSI command packet of the command that cause the
831 * action = error action to take (see action_t)
836 **************************************************************************/
838 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
840 struct scsi_qla_host *ha;
841 int bus, target, lun;
846 int wait_for_target = -1;
847 DECLARE_COMPLETION_ONSTACK(wait);
849 ENTER("qla1280_error_action");
851 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
852 sp = (struct srb *)CMD_SP(cmd);
853 bus = SCSI_BUS_32(cmd);
854 target = SCSI_TCN_32(cmd);
855 lun = SCSI_LUN_32(cmd);
857 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
858 RD_REG_WORD(&ha->iobase->istatus));
860 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
861 RD_REG_WORD(&ha->iobase->host_cmd),
862 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
865 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
866 "Handle=0x%p, action=0x%x\n",
867 ha->host_no, cmd, CMD_HANDLE(cmd), action);
870 * Check to see if we have the command in the outstanding_cmds[]
871 * array. If not then it must have completed before this error
872 * action was initiated. If the error_action isn't ABORT_COMMAND
873 * then the driver must proceed with the requested action.
876 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
877 if (sp == ha->outstanding_cmds[i]) {
879 sp->wait = &wait; /* we'll wait for it to complete */
884 if (found < 0) { /* driver doesn't have command */
886 if (qla1280_verbose) {
888 "scsi(%ld:%d:%d:%d): specified command has "
889 "already completed.\n", ha->host_no, bus,
897 dprintk(1, "qla1280: RISC aborting command\n");
899 * The abort might fail due to race when the host_lock
900 * is released to issue the abort. As such, we
901 * don't bother to check the return status.
904 qla1280_abort_command(ha, sp, found);
910 "scsi(%ld:%d:%d:%d): Queueing device reset "
911 "command.\n", ha->host_no, bus, target, lun);
912 if (qla1280_device_reset(ha, bus, target) == 0) {
913 /* issued device reset, set wait conditions */
915 wait_for_target = target;
921 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
922 "reset.\n", ha->host_no, bus);
923 if (qla1280_bus_reset(ha, bus) == 0) {
924 /* issued bus reset, set wait conditions */
931 if (qla1280_verbose) {
933 "scsi(%ld): Issued ADAPTER RESET\n",
935 printk(KERN_INFO "scsi(%ld): I/O processing will "
936 "continue automatically\n", ha->host_no);
938 ha->flags.reset_active = 1;
940 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
944 ha->flags.reset_active = 0;
948 * At this point, the host_lock has been released and retaken
949 * by the issuance of the mailbox command.
950 * Wait for the command passed in by the mid-layer if it
951 * was found by the driver. It might have been returned
952 * between eh recovery steps, hence the check of the "found"
957 result = _qla1280_wait_for_single_command(ha, sp, &wait);
959 if (action == ABORT_COMMAND && result != SUCCESS) {
961 "scsi(%li:%i:%i:%i): "
962 "Unable to abort command!\n",
963 ha->host_no, bus, target, lun);
967 * If the command passed in by the mid-layer has been
968 * returned by the board, then wait for any additional
969 * commands which are supposed to complete based upon
972 * All commands are unconditionally returned during a
973 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
976 if (result == SUCCESS && wait_for_bus >= 0) {
977 result = qla1280_wait_for_pending_commands(ha,
978 wait_for_bus, wait_for_target);
981 dprintk(1, "RESET returning %d\n", result);
983 LEAVE("qla1280_error_action");
987 /**************************************************************************
989 * Abort the specified SCSI command(s).
990 **************************************************************************/
992 qla1280_eh_abort(struct scsi_cmnd * cmd)
996 spin_lock_irq(cmd->device->host->host_lock);
997 rc = qla1280_error_action(cmd, ABORT_COMMAND);
998 spin_unlock_irq(cmd->device->host->host_lock);
1003 /**************************************************************************
1004 * qla1280_device_reset
1005 * Reset the specified SCSI device
1006 **************************************************************************/
1008 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1012 spin_lock_irq(cmd->device->host->host_lock);
1013 rc = qla1280_error_action(cmd, DEVICE_RESET);
1014 spin_unlock_irq(cmd->device->host->host_lock);
1019 /**************************************************************************
1021 * Reset the specified bus.
1022 **************************************************************************/
1024 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1028 spin_lock_irq(cmd->device->host->host_lock);
1029 rc = qla1280_error_action(cmd, BUS_RESET);
1030 spin_unlock_irq(cmd->device->host->host_lock);
1035 /**************************************************************************
1036 * qla1280_adapter_reset
1037 * Reset the specified adapter (both channels)
1038 **************************************************************************/
1040 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1044 spin_lock_irq(cmd->device->host->host_lock);
1045 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1046 spin_unlock_irq(cmd->device->host->host_lock);
1052 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1053 sector_t capacity, int geom[])
1055 int heads, sectors, cylinders;
1059 cylinders = (unsigned long)capacity / (heads * sectors);
1060 if (cylinders > 1024) {
1063 cylinders = (unsigned long)capacity / (heads * sectors);
1064 /* if (cylinders > 1023)
1065 cylinders = 1023; */
1070 geom[2] = cylinders;
1076 /* disable risc and host interrupts */
1078 qla1280_disable_intrs(struct scsi_qla_host *ha)
1080 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1081 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1084 /* enable risc and host interrupts */
1086 qla1280_enable_intrs(struct scsi_qla_host *ha)
1088 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1089 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1092 /**************************************************************************
1093 * qla1280_intr_handler
1094 * Handles the H/W interrupt
1095 **************************************************************************/
1097 qla1280_intr_handler(int irq, void *dev_id)
1099 struct scsi_qla_host *ha;
1100 struct device_reg __iomem *reg;
1104 ENTER_INTR ("qla1280_intr_handler");
1105 ha = (struct scsi_qla_host *)dev_id;
1107 spin_lock(ha->host->host_lock);
1112 qla1280_disable_intrs(ha);
1114 data = qla1280_debounce_register(®->istatus);
1115 /* Check for pending interrupts. */
1116 if (data & RISC_INT) {
1117 qla1280_isr(ha, &ha->done_q);
1120 if (!list_empty(&ha->done_q))
1123 spin_unlock(ha->host->host_lock);
1125 qla1280_enable_intrs(ha);
1127 LEAVE_INTR("qla1280_intr_handler");
1128 return IRQ_RETVAL(handled);
1133 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1136 uint16_t mb[MAILBOX_REGISTER_COUNT];
1142 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1144 /* Set Target Parameters. */
1145 mb[0] = MBC_SET_TARGET_PARAMETERS;
1146 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1147 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1148 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1149 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1150 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1151 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1152 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1153 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1154 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1156 if (IS_ISP1x160(ha)) {
1157 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1158 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1159 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1160 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1163 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1165 mb[3] |= nv->bus[bus].target[target].sync_period;
1167 status = qla1280_mailbox_command(ha, mr, mb);
1169 /* Set Device Queue Parameters. */
1170 for (lun = 0; lun < MAX_LUNS; lun++) {
1171 mb[0] = MBC_SET_DEVICE_QUEUE;
1172 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1174 mb[2] = nv->bus[bus].max_queue_depth;
1175 mb[3] = nv->bus[bus].target[target].execution_throttle;
1176 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1180 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1181 "qla1280_set_target_parameters() failed\n",
1182 ha->host_no, bus, target);
1187 /**************************************************************************
1188 * qla1280_slave_configure
1191 * Determines the queue depth for a given device. There are two ways
1192 * a queue depth can be obtained for a tagged queueing device. One
1193 * way is the default queue depth which is determined by whether
1194 * If it is defined, then it is used
1195 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1196 * default queue depth (dependent on the number of hardware SCBs).
1197 **************************************************************************/
1199 qla1280_slave_configure(struct scsi_device *device)
1201 struct scsi_qla_host *ha;
1202 int default_depth = 3;
1203 int bus = device->channel;
1204 int target = device->id;
1207 unsigned long flags;
1209 ha = (struct scsi_qla_host *)device->host->hostdata;
1212 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1215 if (device->tagged_supported &&
1216 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1217 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1219 scsi_change_queue_depth(device, default_depth);
1222 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1223 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1224 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1226 if (driver_setup.no_sync ||
1227 (driver_setup.sync_mask &&
1228 (~driver_setup.sync_mask & (1 << target))))
1229 nv->bus[bus].target[target].parameter.enable_sync = 0;
1230 if (driver_setup.no_wide ||
1231 (driver_setup.wide_mask &&
1232 (~driver_setup.wide_mask & (1 << target))))
1233 nv->bus[bus].target[target].parameter.enable_wide = 0;
1234 if (IS_ISP1x160(ha)) {
1235 if (driver_setup.no_ppr ||
1236 (driver_setup.ppr_mask &&
1237 (~driver_setup.ppr_mask & (1 << target))))
1238 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1241 spin_lock_irqsave(ha->host->host_lock, flags);
1242 if (nv->bus[bus].target[target].parameter.enable_sync)
1243 status = qla1280_set_target_parameters(ha, bus, target);
1244 qla1280_get_target_parameters(ha, device);
1245 spin_unlock_irqrestore(ha->host->host_lock, flags);
1252 * Process completed commands.
1255 * ha = adapter block pointer.
1258 qla1280_done(struct scsi_qla_host *ha)
1261 struct list_head *done_q;
1262 int bus, target, lun;
1263 struct scsi_cmnd *cmd;
1265 ENTER("qla1280_done");
1267 done_q = &ha->done_q;
1269 while (!list_empty(done_q)) {
1270 sp = list_entry(done_q->next, struct srb, list);
1272 list_del(&sp->list);
1275 bus = SCSI_BUS_32(cmd);
1276 target = SCSI_TCN_32(cmd);
1277 lun = SCSI_LUN_32(cmd);
1279 switch ((CMD_RESULT(cmd) >> 16)) {
1281 /* Issue marker command. */
1282 if (!ha->flags.abort_isp_active)
1283 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1286 sp->flags &= ~SRB_ABORT_PENDING;
1287 sp->flags |= SRB_ABORTED;
1293 /* Release memory used for this I/O */
1294 scsi_dma_unmap(cmd);
1296 /* Call the mid-level driver interrupt handler */
1299 if (sp->wait == NULL)
1300 (*(cmd)->scsi_done)(cmd);
1304 LEAVE("qla1280_done");
1308 * Translates a ISP error to a Linux SCSI error
1311 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1313 int host_status = DID_ERROR;
1314 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1315 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1316 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1317 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1318 #if DEBUG_QLA1280_INTR
1319 static char *reason[] = {
1331 #endif /* DEBUG_QLA1280_INTR */
1333 ENTER("qla1280_return_status");
1335 #if DEBUG_QLA1280_INTR
1337 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1342 switch (comp_status) {
1344 host_status = DID_OK;
1348 if (!(state_flags & SF_GOT_BUS))
1349 host_status = DID_NO_CONNECT;
1350 else if (!(state_flags & SF_GOT_TARGET))
1351 host_status = DID_BAD_TARGET;
1352 else if (!(state_flags & SF_SENT_CDB))
1353 host_status = DID_ERROR;
1354 else if (!(state_flags & SF_TRANSFERRED_DATA))
1355 host_status = DID_ERROR;
1356 else if (!(state_flags & SF_GOT_STATUS))
1357 host_status = DID_ERROR;
1358 else if (!(state_flags & SF_GOT_SENSE))
1359 host_status = DID_ERROR;
1363 host_status = DID_RESET;
1367 host_status = DID_ABORT;
1371 host_status = DID_TIME_OUT;
1374 case CS_DATA_OVERRUN:
1375 dprintk(2, "Data overrun 0x%x\n", residual_length);
1376 dprintk(2, "qla1280_return_status: response packet data\n");
1377 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1378 host_status = DID_ERROR;
1381 case CS_DATA_UNDERRUN:
1382 if ((scsi_bufflen(cp) - residual_length) <
1385 "scsi: Underflow detected - retrying "
1387 host_status = DID_ERROR;
1389 scsi_set_resid(cp, residual_length);
1390 host_status = DID_OK;
1395 host_status = DID_ERROR;
1399 #if DEBUG_QLA1280_INTR
1400 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1401 reason[host_status], scsi_status);
1404 LEAVE("qla1280_return_status");
1406 return (scsi_status & 0xff) | (host_status << 16);
1409 /****************************************************************************/
1410 /* QLogic ISP1280 Hardware Support Functions. */
1411 /****************************************************************************/
1414 * qla1280_initialize_adapter
1418 * ha = adapter block pointer.
1424 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1426 struct device_reg __iomem *reg;
1429 unsigned long flags;
1431 ENTER("qla1280_initialize_adapter");
1433 /* Clear adapter flags. */
1434 ha->flags.online = 0;
1435 ha->flags.disable_host_adapter = 0;
1436 ha->flags.reset_active = 0;
1437 ha->flags.abort_isp_active = 0;
1439 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1440 if (ia64_platform_is("sn2")) {
1441 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
1442 "dual channel lockup workaround\n", ha->host_no);
1443 ha->flags.use_pci_vchannel = 1;
1444 driver_setup.no_nvram = 1;
1448 /* TODO: implement support for the 1040 nvram format */
1450 driver_setup.no_nvram = 1;
1452 dprintk(1, "Configure PCI space for adapter...\n");
1456 /* Insure mailbox registers are free. */
1457 WRT_REG_WORD(®->semaphore, 0);
1458 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1459 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1460 RD_REG_WORD(®->host_cmd);
1462 if (qla1280_read_nvram(ha)) {
1463 dprintk(2, "qla1280_initialize_adapter: failed to read "
1468 * It's necessary to grab the spin here as qla1280_mailbox_command
1469 * needs to be able to drop the lock unconditionally to wait
1472 spin_lock_irqsave(ha->host->host_lock, flags);
1474 status = qla1280_load_firmware(ha);
1476 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1481 /* Setup adapter based on NVRAM parameters. */
1482 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1483 qla1280_nvram_config(ha);
1485 if (ha->flags.disable_host_adapter) {
1490 status = qla1280_init_rings(ha);
1494 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1495 for (bus = 0; bus < ha->ports; bus++) {
1496 if (!ha->bus_settings[bus].disable_scsi_reset &&
1497 qla1280_bus_reset(ha, bus) &&
1498 qla1280_bus_reset(ha, bus))
1499 ha->bus_settings[bus].scsi_bus_dead = 1;
1502 ha->flags.online = 1;
1504 spin_unlock_irqrestore(ha->host->host_lock, flags);
1507 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1509 LEAVE("qla1280_initialize_adapter");
1514 * qla1280_request_firmware
1515 * Acquire firmware for chip. Retain in memory
1516 * for error recovery.
1519 * ha = adapter block pointer.
1522 * Pointer to firmware image or an error code
1523 * cast to pointer via ERR_PTR().
1525 static const struct firmware *
1526 qla1280_request_firmware(struct scsi_qla_host *ha)
1528 const struct firmware *fw;
1533 spin_unlock_irq(ha->host->host_lock);
1534 mutex_lock(&qla1280_firmware_mutex);
1536 index = ql1280_board_tbl[ha->devnum].fw_index;
1537 fw = qla1280_fw_tbl[index].fw;
1541 fwname = qla1280_fw_tbl[index].fwname;
1542 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1545 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1550 if ((fw->size % 2) || (fw->size < 6)) {
1551 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1553 release_firmware(fw);
1554 fw = ERR_PTR(-EINVAL);
1558 qla1280_fw_tbl[index].fw = fw;
1561 ha->fwver1 = fw->data[0];
1562 ha->fwver2 = fw->data[1];
1563 ha->fwver3 = fw->data[2];
1565 mutex_unlock(&qla1280_firmware_mutex);
1566 spin_lock_irq(ha->host->host_lock);
1572 * Test chip for proper operation.
1575 * ha = adapter block pointer.
1581 qla1280_chip_diag(struct scsi_qla_host *ha)
1583 uint16_t mb[MAILBOX_REGISTER_COUNT];
1584 struct device_reg __iomem *reg = ha->iobase;
1588 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1590 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1592 /* Soft reset chip and wait for it to finish. */
1593 WRT_REG_WORD(®->ictrl, ISP_RESET);
1596 * We can't do a traditional PCI write flush here by reading
1597 * back the register. The card will not respond once the reset
1598 * is in action and we end up with a machine check exception
1599 * instead. Nothing to do but wait and hope for the best.
1600 * A portable pci_write_flush(pdev) call would be very useful here.
1603 data = qla1280_debounce_register(®->ictrl);
1605 * Yet another QLogic gem ;-(
1607 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1609 data = RD_REG_WORD(®->ictrl);
1615 /* Reset register cleared by chip reset. */
1616 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1618 WRT_REG_WORD(®->cfg_1, 0);
1620 /* Reset RISC and disable BIOS which
1621 allows RISC to execute out of RAM. */
1622 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1623 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1625 RD_REG_WORD(®->id_l); /* Flush PCI write */
1626 data = qla1280_debounce_register(®->mailbox0);
1629 * I *LOVE* this code!
1631 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1633 data = RD_REG_WORD(®->mailbox0);
1639 /* Check product ID of chip */
1640 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1642 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1643 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1644 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1645 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1646 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1647 printk(KERN_INFO "qla1280: Wrong product ID = "
1648 "0x%x,0x%x,0x%x,0x%x\n",
1649 RD_REG_WORD(®->mailbox1),
1650 RD_REG_WORD(®->mailbox2),
1651 RD_REG_WORD(®->mailbox3),
1652 RD_REG_WORD(®->mailbox4));
1657 * Enable ints early!!!
1659 qla1280_enable_intrs(ha);
1661 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1662 /* Wrap Incoming Mailboxes Test. */
1663 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1672 status = qla1280_mailbox_command(ha, 0xff, mb);
1676 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1677 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1679 printk(KERN_INFO "qla1280: Failed mbox check\n");
1683 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1686 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1691 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1693 /* enter with host_lock acquired */
1695 const struct firmware *fw;
1696 const __le16 *fw_data;
1697 uint16_t risc_address, risc_code_size;
1698 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1701 fw = qla1280_request_firmware(ha);
1705 fw_data = (const __le16 *)&fw->data[0];
1706 ha->fwstart = __le16_to_cpu(fw_data[2]);
1708 /* Load RISC code. */
1709 risc_address = ha->fwstart;
1710 fw_data = (const __le16 *)&fw->data[6];
1711 risc_code_size = (fw->size - 6) / 2;
1713 for (i = 0; i < risc_code_size; i++) {
1714 mb[0] = MBC_WRITE_RAM_WORD;
1715 mb[1] = risc_address + i;
1716 mb[2] = __le16_to_cpu(fw_data[i]);
1718 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1720 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1729 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1731 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1733 /* enter with host_lock acquired */
1734 const struct firmware *fw;
1735 const __le16 *fw_data;
1736 uint16_t risc_address, risc_code_size;
1737 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1738 int err = 0, num, i;
1743 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1748 fw = qla1280_request_firmware(ha);
1752 fw_data = (const __le16 *)&fw->data[0];
1753 ha->fwstart = __le16_to_cpu(fw_data[2]);
1755 /* Load RISC code. */
1756 risc_address = ha->fwstart;
1757 fw_data = (const __le16 *)&fw->data[6];
1758 risc_code_size = (fw->size - 6) / 2;
1760 dprintk(1, "%s: DMA RISC code (%i) words\n",
1761 __func__, risc_code_size);
1764 while (risc_code_size > 0) {
1765 int warn __attribute__((unused)) = 0;
1769 if (cnt > risc_code_size)
1770 cnt = risc_code_size;
1772 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1774 fw_data, cnt, num, risc_address);
1775 for(i = 0; i < cnt; i++)
1776 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1778 mb[0] = MBC_LOAD_RAM;
1779 mb[1] = risc_address;
1781 mb[3] = ha->request_dma & 0xffff;
1782 mb[2] = (ha->request_dma >> 16) & 0xffff;
1783 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1784 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1785 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1787 (void *)(long)ha->request_dma,
1788 mb[6], mb[7], mb[2], mb[3]);
1789 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1792 printk(KERN_ERR "scsi(%li): Failed to load partial "
1793 "segment of f\n", ha->host_no);
1798 mb[0] = MBC_DUMP_RAM;
1799 mb[1] = risc_address;
1801 mb[3] = p_tbuf & 0xffff;
1802 mb[2] = (p_tbuf >> 16) & 0xffff;
1803 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1804 mb[6] = upper_32_bits(p_tbuf) >> 16;
1806 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1810 "Failed to dump partial segment of f/w\n");
1813 sp = (uint8_t *)ha->request_ring;
1814 for (i = 0; i < (cnt << 1); i++) {
1815 if (tbuf[i] != sp[i] && warn++ < 10) {
1816 printk(KERN_ERR "%s: FW compare error @ "
1817 "byte(0x%x) loop#=%x\n",
1819 printk(KERN_ERR "%s: FWbyte=%x "
1821 __func__, sp[i], tbuf[i]);
1826 risc_address += cnt;
1827 risc_code_size = risc_code_size - cnt;
1828 fw_data = fw_data + cnt;
1834 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1840 qla1280_start_firmware(struct scsi_qla_host *ha)
1842 uint16_t mb[MAILBOX_REGISTER_COUNT];
1845 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1848 /* Verify checksum of loaded RISC code. */
1849 mb[0] = MBC_VERIFY_CHECKSUM;
1850 /* mb[1] = ql12_risc_code_addr01; */
1851 mb[1] = ha->fwstart;
1852 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1854 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1858 /* Start firmware execution. */
1859 dprintk(1, "%s: start firmware running.\n", __func__);
1860 mb[0] = MBC_EXECUTE_FIRMWARE;
1861 mb[1] = ha->fwstart;
1862 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1864 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1872 qla1280_load_firmware(struct scsi_qla_host *ha)
1874 /* enter with host_lock taken */
1877 err = qla1280_chip_diag(ha);
1881 err = qla1280_load_firmware_pio(ha);
1883 err = qla1280_load_firmware_dma(ha);
1886 err = qla1280_start_firmware(ha);
1895 * ha = adapter block pointer.
1896 * ha->request_ring = request ring virtual address
1897 * ha->response_ring = response ring virtual address
1898 * ha->request_dma = request ring physical address
1899 * ha->response_dma = response ring physical address
1905 qla1280_init_rings(struct scsi_qla_host *ha)
1907 uint16_t mb[MAILBOX_REGISTER_COUNT];
1910 ENTER("qla1280_init_rings");
1912 /* Clear outstanding commands array. */
1913 memset(ha->outstanding_cmds, 0,
1914 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1916 /* Initialize request queue. */
1917 ha->request_ring_ptr = ha->request_ring;
1918 ha->req_ring_index = 0;
1919 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1920 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1921 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1922 mb[1] = REQUEST_ENTRY_CNT;
1923 mb[3] = ha->request_dma & 0xffff;
1924 mb[2] = (ha->request_dma >> 16) & 0xffff;
1926 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1927 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1928 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1929 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1931 /* Initialize response queue. */
1932 ha->response_ring_ptr = ha->response_ring;
1933 ha->rsp_ring_index = 0;
1934 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1935 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1936 mb[1] = RESPONSE_ENTRY_CNT;
1937 mb[3] = ha->response_dma & 0xffff;
1938 mb[2] = (ha->response_dma >> 16) & 0xffff;
1940 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1941 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1942 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1943 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1948 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1950 LEAVE("qla1280_init_rings");
1955 qla1280_print_settings(struct nvram *nv)
1957 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1958 nv->bus[0].config_1.initiator_id);
1959 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1960 nv->bus[1].config_1.initiator_id);
1962 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1963 nv->bus[0].bus_reset_delay);
1964 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1965 nv->bus[1].bus_reset_delay);
1967 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1968 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1969 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1970 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1972 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1973 nv->bus[0].config_2.async_data_setup_time);
1974 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1975 nv->bus[1].config_2.async_data_setup_time);
1977 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1978 nv->bus[0].config_2.req_ack_active_negation);
1979 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1980 nv->bus[1].config_2.req_ack_active_negation);
1982 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1983 nv->bus[0].config_2.data_line_active_negation);
1984 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1985 nv->bus[1].config_2.data_line_active_negation);
1987 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1988 nv->cntr_flags_1.disable_loading_risc_code);
1990 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1991 nv->cntr_flags_1.enable_64bit_addressing);
1993 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1994 nv->bus[0].selection_timeout);
1995 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1996 nv->bus[1].selection_timeout);
1998 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1999 nv->bus[0].max_queue_depth);
2000 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
2001 nv->bus[1].max_queue_depth);
2005 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
2007 struct nvram *nv = &ha->nvram;
2009 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
2010 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
2011 nv->bus[bus].target[target].parameter.tag_queuing = 1;
2012 nv->bus[bus].target[target].parameter.enable_sync = 1;
2013 #if 1 /* Some SCSI Processors do not seem to like this */
2014 nv->bus[bus].target[target].parameter.enable_wide = 1;
2016 nv->bus[bus].target[target].execution_throttle =
2017 nv->bus[bus].max_queue_depth - 1;
2018 nv->bus[bus].target[target].parameter.parity_checking = 1;
2019 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
2021 if (IS_ISP1x160(ha)) {
2022 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2023 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2024 nv->bus[bus].target[target].sync_period = 9;
2025 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2026 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2027 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2029 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2030 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2031 nv->bus[bus].target[target].sync_period = 10;
2036 qla1280_set_defaults(struct scsi_qla_host *ha)
2038 struct nvram *nv = &ha->nvram;
2041 dprintk(1, "Using defaults for NVRAM: \n");
2042 memset(nv, 0, sizeof(struct nvram));
2044 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2045 nv->firmware_feature.f.enable_fast_posting = 1;
2046 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2047 nv->termination.scsi_bus_0_control = 3;
2048 nv->termination.scsi_bus_1_control = 3;
2049 nv->termination.auto_term_support = 1;
2052 * Set default FIFO magic - What appropriate values would be here
2053 * is unknown. This is what I have found testing with 12160s.
2055 * Now, I would love the magic decoder ring for this one, the
2056 * header file provided by QLogic seems to be bogus or incomplete
2059 nv->isp_config.burst_enable = 1;
2061 nv->isp_config.fifo_threshold |= 3;
2063 nv->isp_config.fifo_threshold |= 4;
2065 if (IS_ISP1x160(ha))
2066 nv->isp_parameter = 0x01; /* fast memory enable */
2068 for (bus = 0; bus < MAX_BUSES; bus++) {
2069 nv->bus[bus].config_1.initiator_id = 7;
2070 nv->bus[bus].config_2.req_ack_active_negation = 1;
2071 nv->bus[bus].config_2.data_line_active_negation = 1;
2072 nv->bus[bus].selection_timeout = 250;
2073 nv->bus[bus].max_queue_depth = 32;
2075 if (IS_ISP1040(ha)) {
2076 nv->bus[bus].bus_reset_delay = 3;
2077 nv->bus[bus].config_2.async_data_setup_time = 6;
2078 nv->bus[bus].retry_delay = 1;
2080 nv->bus[bus].bus_reset_delay = 5;
2081 nv->bus[bus].config_2.async_data_setup_time = 8;
2084 for (target = 0; target < MAX_TARGETS; target++)
2085 qla1280_set_target_defaults(ha, bus, target);
2090 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2092 struct nvram *nv = &ha->nvram;
2093 uint16_t mb[MAILBOX_REGISTER_COUNT];
2097 /* Set Target Parameters. */
2098 mb[0] = MBC_SET_TARGET_PARAMETERS;
2099 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2102 * Do not enable sync and ppr for the initial INQUIRY run. We
2103 * enable this later if we determine the target actually
2106 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2107 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2109 if (IS_ISP1x160(ha))
2110 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2112 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2113 mb[3] |= nv->bus[bus].target[target].sync_period;
2114 status = qla1280_mailbox_command(ha, 0x0f, mb);
2116 /* Save Tag queuing enable flag. */
2117 flag = (BIT_0 << target);
2118 if (nv->bus[bus].target[target].parameter.tag_queuing)
2119 ha->bus_settings[bus].qtag_enables |= flag;
2121 /* Save Device enable flag. */
2122 if (IS_ISP1x160(ha)) {
2123 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2124 ha->bus_settings[bus].device_enables |= flag;
2125 ha->bus_settings[bus].lun_disables |= 0;
2127 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2128 ha->bus_settings[bus].device_enables |= flag;
2129 /* Save LUN disable flag. */
2130 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2131 ha->bus_settings[bus].lun_disables |= flag;
2134 /* Set Device Queue Parameters. */
2135 for (lun = 0; lun < MAX_LUNS; lun++) {
2136 mb[0] = MBC_SET_DEVICE_QUEUE;
2137 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2139 mb[2] = nv->bus[bus].max_queue_depth;
2140 mb[3] = nv->bus[bus].target[target].execution_throttle;
2141 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2148 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2150 struct nvram *nv = &ha->nvram;
2151 uint16_t mb[MAILBOX_REGISTER_COUNT];
2154 /* SCSI Reset Disable. */
2155 ha->bus_settings[bus].disable_scsi_reset =
2156 nv->bus[bus].config_1.scsi_reset_disable;
2159 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2160 mb[0] = MBC_SET_INITIATOR_ID;
2161 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2162 ha->bus_settings[bus].id;
2163 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2166 ha->bus_settings[bus].bus_reset_delay =
2167 nv->bus[bus].bus_reset_delay;
2169 /* Command queue depth per device. */
2170 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2172 /* Set target parameters. */
2173 for (target = 0; target < MAX_TARGETS; target++)
2174 status |= qla1280_config_target(ha, bus, target);
2180 qla1280_nvram_config(struct scsi_qla_host *ha)
2182 struct device_reg __iomem *reg = ha->iobase;
2183 struct nvram *nv = &ha->nvram;
2184 int bus, target, status = 0;
2185 uint16_t mb[MAILBOX_REGISTER_COUNT];
2187 ENTER("qla1280_nvram_config");
2189 if (ha->nvram_valid) {
2190 /* Always force AUTO sense for LINUX SCSI */
2191 for (bus = 0; bus < MAX_BUSES; bus++)
2192 for (target = 0; target < MAX_TARGETS; target++) {
2193 nv->bus[bus].target[target].parameter.
2194 auto_request_sense = 1;
2197 qla1280_set_defaults(ha);
2200 qla1280_print_settings(nv);
2202 /* Disable RISC load of firmware. */
2203 ha->flags.disable_risc_code_load =
2204 nv->cntr_flags_1.disable_loading_risc_code;
2206 if (IS_ISP1040(ha)) {
2207 uint16_t hwrev, cfg1, cdma_conf, ddma_conf;
2209 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2211 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2212 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2213 ddma_conf = RD_REG_WORD(®->ddma_cfg);
2215 /* Busted fifo, says mjacob. */
2216 if (hwrev != ISP_CFG0_1040A)
2217 cfg1 |= nv->isp_config.fifo_threshold << 4;
2219 cfg1 |= nv->isp_config.burst_enable << 2;
2220 WRT_REG_WORD(®->cfg_1, cfg1);
2222 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2223 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2225 uint16_t cfg1, term;
2227 /* Set ISP hardware DMA burst */
2228 cfg1 = nv->isp_config.fifo_threshold << 4;
2229 cfg1 |= nv->isp_config.burst_enable << 2;
2230 /* Enable DMA arbitration on dual channel controllers */
2233 WRT_REG_WORD(®->cfg_1, cfg1);
2235 /* Set SCSI termination. */
2236 WRT_REG_WORD(®->gpio_enable,
2237 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2238 term = nv->termination.scsi_bus_1_control;
2239 term |= nv->termination.scsi_bus_0_control << 2;
2240 term |= nv->termination.auto_term_support << 7;
2241 RD_REG_WORD(®->id_l); /* Flush PCI write */
2242 WRT_REG_WORD(®->gpio_data, term);
2244 RD_REG_WORD(®->id_l); /* Flush PCI write */
2246 /* ISP parameter word. */
2247 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2248 mb[1] = nv->isp_parameter;
2249 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2251 if (IS_ISP1x40(ha)) {
2252 /* clock rate - for qla1240 and older, only */
2253 mb[0] = MBC_SET_CLOCK_RATE;
2255 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2258 /* Firmware feature word. */
2259 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2260 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2261 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2262 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2263 #if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2264 if (ia64_platform_is("sn2")) {
2265 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
2266 "workaround\n", ha->host_no);
2267 mb[1] |= nv->firmware_feature.f.unused_9 << 9; /* XXX */
2270 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2272 /* Retry count and delay. */
2273 mb[0] = MBC_SET_RETRY_COUNT;
2274 mb[1] = nv->bus[0].retry_count;
2275 mb[2] = nv->bus[0].retry_delay;
2276 mb[6] = nv->bus[1].retry_count;
2277 mb[7] = nv->bus[1].retry_delay;
2278 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2279 BIT_1 | BIT_0, &mb[0]);
2281 /* ASYNC data setup time. */
2282 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2283 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2284 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2285 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2287 /* Active negation states. */
2288 mb[0] = MBC_SET_ACTIVE_NEGATION;
2290 if (nv->bus[0].config_2.req_ack_active_negation)
2292 if (nv->bus[0].config_2.data_line_active_negation)
2295 if (nv->bus[1].config_2.req_ack_active_negation)
2297 if (nv->bus[1].config_2.data_line_active_negation)
2299 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2301 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2302 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2303 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2306 mb[0] = MBC_SET_PCI_CONTROL;
2307 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2308 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2309 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2311 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2313 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2315 /* Selection timeout. */
2316 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2317 mb[1] = nv->bus[0].selection_timeout;
2318 mb[2] = nv->bus[1].selection_timeout;
2319 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2321 for (bus = 0; bus < ha->ports; bus++)
2322 status |= qla1280_config_bus(ha, bus);
2325 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2327 LEAVE("qla1280_nvram_config");
2332 * Get NVRAM data word
2333 * Calculates word position in NVRAM and calls request routine to
2334 * get the word from NVRAM.
2337 * ha = adapter block pointer.
2338 * address = NVRAM word address.
2344 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2349 nv_cmd = address << 16;
2350 nv_cmd |= NV_READ_OP;
2352 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2354 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2362 * Sends read command to NVRAM and gets data from NVRAM.
2365 * ha = adapter block pointer.
2366 * nv_cmd = Bit 26 = start bit
2367 * Bit 25, 24 = opcode
2368 * Bit 23-16 = address
2369 * Bit 15-0 = write data
2375 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2377 struct device_reg __iomem *reg = ha->iobase;
2382 /* Send command to NVRAM. */
2385 for (cnt = 0; cnt < 11; cnt++) {
2386 if (nv_cmd & BIT_31)
2387 qla1280_nv_write(ha, NV_DATA_OUT);
2389 qla1280_nv_write(ha, 0);
2393 /* Read data from NVRAM. */
2395 for (cnt = 0; cnt < 16; cnt++) {
2396 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2397 RD_REG_WORD(®->id_l); /* Flush PCI write */
2400 reg_data = RD_REG_WORD(®->nvram);
2401 if (reg_data & NV_DATA_IN)
2403 WRT_REG_WORD(®->nvram, NV_SELECT);
2404 RD_REG_WORD(®->id_l); /* Flush PCI write */
2408 /* Deselect chip. */
2410 WRT_REG_WORD(®->nvram, NV_DESELECT);
2411 RD_REG_WORD(®->id_l); /* Flush PCI write */
2418 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2420 struct device_reg __iomem *reg = ha->iobase;
2422 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2423 RD_REG_WORD(®->id_l); /* Flush PCI write */
2425 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2426 RD_REG_WORD(®->id_l); /* Flush PCI write */
2428 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2429 RD_REG_WORD(®->id_l); /* Flush PCI write */
2435 * Issue mailbox command and waits for completion.
2438 * ha = adapter block pointer.
2439 * mr = mailbox registers to load.
2440 * mb = data pointer for mailbox registers.
2443 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2449 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2451 struct device_reg __iomem *reg = ha->iobase;
2454 uint16_t *optr, *iptr;
2455 uint16_t __iomem *mptr;
2457 DECLARE_COMPLETION_ONSTACK(wait);
2459 ENTER("qla1280_mailbox_command");
2461 if (ha->mailbox_wait) {
2462 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2464 ha->mailbox_wait = &wait;
2467 * We really should start out by verifying that the mailbox is
2468 * available before starting sending the command data
2470 /* Load mailbox registers. */
2471 mptr = (uint16_t __iomem *) ®->mailbox0;
2473 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2475 WRT_REG_WORD(mptr, (*iptr));
2483 /* Issue set host interrupt command. */
2485 /* set up a timer just in case we're really jammed */
2486 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2487 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
2489 spin_unlock_irq(ha->host->host_lock);
2490 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2491 data = qla1280_debounce_register(®->istatus);
2493 wait_for_completion(&wait);
2494 del_timer_sync(&ha->mailbox_timer);
2496 spin_lock_irq(ha->host->host_lock);
2498 ha->mailbox_wait = NULL;
2500 /* Check for mailbox command timeout. */
2501 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2502 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2503 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2505 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2506 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2507 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2508 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2509 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2510 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2511 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2515 /* Load return mailbox registers. */
2517 iptr = (uint16_t *) &ha->mailbox_out[0];
2518 mr = MAILBOX_REGISTER_COUNT;
2519 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2521 if (ha->flags.reset_marker)
2522 qla1280_rst_aen(ha);
2525 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2526 "0x%x ****\n", mb[0]);
2528 LEAVE("qla1280_mailbox_command");
2534 * Polls ISP for interrupts.
2537 * ha = adapter block pointer.
2540 qla1280_poll(struct scsi_qla_host *ha)
2542 struct device_reg __iomem *reg = ha->iobase;
2546 /* ENTER("qla1280_poll"); */
2548 /* Check for pending interrupts. */
2549 data = RD_REG_WORD(®->istatus);
2550 if (data & RISC_INT)
2551 qla1280_isr(ha, &done_q);
2553 if (!ha->mailbox_wait) {
2554 if (ha->flags.reset_marker)
2555 qla1280_rst_aen(ha);
2558 if (!list_empty(&done_q))
2561 /* LEAVE("qla1280_poll"); */
2566 * Issue SCSI bus reset.
2569 * ha = adapter block pointer.
2570 * bus = SCSI bus number.
2576 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2578 uint16_t mb[MAILBOX_REGISTER_COUNT];
2579 uint16_t reset_delay;
2582 dprintk(3, "qla1280_bus_reset: entered\n");
2584 if (qla1280_verbose)
2585 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2588 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2589 mb[0] = MBC_BUS_RESET;
2590 mb[1] = reset_delay;
2591 mb[2] = (uint16_t) bus;
2592 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2595 if (ha->bus_settings[bus].failed_reset_count > 2)
2596 ha->bus_settings[bus].scsi_bus_dead = 1;
2597 ha->bus_settings[bus].failed_reset_count++;
2599 spin_unlock_irq(ha->host->host_lock);
2600 ssleep(reset_delay);
2601 spin_lock_irq(ha->host->host_lock);
2603 ha->bus_settings[bus].scsi_bus_dead = 0;
2604 ha->bus_settings[bus].failed_reset_count = 0;
2605 ha->bus_settings[bus].reset_marker = 0;
2606 /* Issue marker command. */
2607 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2611 * We should probably call qla1280_set_target_parameters()
2612 * here as well for all devices on the bus.
2616 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2618 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2624 * qla1280_device_reset
2625 * Issue bus device reset message to the target.
2628 * ha = adapter block pointer.
2629 * bus = SCSI BUS number.
2636 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2638 uint16_t mb[MAILBOX_REGISTER_COUNT];
2641 ENTER("qla1280_device_reset");
2643 mb[0] = MBC_ABORT_TARGET;
2644 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2646 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2648 /* Issue marker command. */
2649 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2652 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2654 LEAVE("qla1280_device_reset");
2659 * qla1280_abort_command
2660 * Abort command aborts a specified IOCB.
2663 * ha = adapter block pointer.
2664 * sp = SB structure pointer.
2670 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2672 uint16_t mb[MAILBOX_REGISTER_COUNT];
2673 unsigned int bus, target, lun;
2676 ENTER("qla1280_abort_command");
2678 bus = SCSI_BUS_32(sp->cmd);
2679 target = SCSI_TCN_32(sp->cmd);
2680 lun = SCSI_LUN_32(sp->cmd);
2682 sp->flags |= SRB_ABORT_PENDING;
2684 mb[0] = MBC_ABORT_COMMAND;
2685 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2686 mb[2] = handle >> 16;
2687 mb[3] = handle & 0xffff;
2688 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2691 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2692 sp->flags &= ~SRB_ABORT_PENDING;
2696 LEAVE("qla1280_abort_command");
2701 * qla1280_reset_adapter
2705 * ha = adapter block pointer.
2708 qla1280_reset_adapter(struct scsi_qla_host *ha)
2710 struct device_reg __iomem *reg = ha->iobase;
2712 ENTER("qla1280_reset_adapter");
2714 /* Disable ISP chip */
2715 ha->flags.online = 0;
2716 WRT_REG_WORD(®->ictrl, ISP_RESET);
2717 WRT_REG_WORD(®->host_cmd,
2718 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2719 RD_REG_WORD(®->id_l); /* Flush PCI write */
2721 LEAVE("qla1280_reset_adapter");
2725 * Issue marker command.
2726 * Function issues marker IOCB.
2729 * ha = adapter block pointer.
2730 * bus = SCSI BUS number
2733 * type = marker modifier
2736 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2738 struct mrk_entry *pkt;
2740 ENTER("qla1280_marker");
2742 /* Get request packet. */
2743 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2744 pkt->entry_type = MARKER_TYPE;
2745 pkt->lun = (uint8_t) lun;
2746 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2747 pkt->modifier = type;
2748 pkt->entry_status = 0;
2750 /* Issue command to ISP */
2751 qla1280_isp_cmd(ha);
2754 LEAVE("qla1280_marker");
2759 * qla1280_64bit_start_scsi
2760 * The start SCSI is responsible for building request packets on
2761 * request ring and modifying ISP input pointer.
2764 * ha = adapter block pointer.
2765 * sp = SB structure pointer.
2768 * 0 = success, was able to issue command.
2770 #ifdef QLA_64BIT_PTR
2772 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2774 struct device_reg __iomem *reg = ha->iobase;
2775 struct scsi_cmnd *cmd = sp->cmd;
2776 cmd_a64_entry_t *pkt;
2778 dma_addr_t dma_handle;
2785 ENTER("qla1280_64bit_start_scsi:");
2787 /* Calculate number of entries and segments required. */
2789 seg_cnt = scsi_dma_map(cmd);
2792 req_cnt += (seg_cnt - 2) / 5;
2793 if ((seg_cnt - 2) % 5)
2796 } else if (seg_cnt < 0) {
2801 if ((req_cnt + 2) >= ha->req_q_cnt) {
2802 /* Calculate number of free request entries. */
2803 cnt = RD_REG_WORD(®->mailbox4);
2804 if (ha->req_ring_index < cnt)
2805 ha->req_q_cnt = cnt - ha->req_ring_index;
2808 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2811 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2812 ha->req_q_cnt, seg_cnt);
2814 /* If room for request in request ring. */
2815 if ((req_cnt + 2) >= ha->req_q_cnt) {
2816 status = SCSI_MLQUEUE_HOST_BUSY;
2817 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
2818 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2823 /* Check for room in outstanding command list. */
2824 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2825 ha->outstanding_cmds[cnt] != NULL; cnt++);
2827 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2828 status = SCSI_MLQUEUE_HOST_BUSY;
2829 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2830 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2834 ha->outstanding_cmds[cnt] = sp;
2835 ha->req_q_cnt -= req_cnt;
2836 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2838 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2839 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2840 dprintk(2, " bus %i, target %i, lun %i\n",
2841 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2842 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2845 * Build command packet.
2847 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2849 pkt->entry_type = COMMAND_A64_TYPE;
2850 pkt->entry_count = (uint8_t) req_cnt;
2851 pkt->sys_define = (uint8_t) ha->req_ring_index;
2852 pkt->entry_status = 0;
2853 pkt->handle = cpu_to_le32(cnt);
2855 /* Zero out remaining portion of packet. */
2856 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2858 /* Set ISP command timeout. */
2859 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
2861 /* Set device target ID and LUN */
2862 pkt->lun = SCSI_LUN_32(cmd);
2863 pkt->target = SCSI_BUS_32(cmd) ?
2864 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2866 /* Enable simple tag queuing if device supports it. */
2867 if (cmd->device->simple_tags)
2868 pkt->control_flags |= cpu_to_le16(BIT_3);
2870 /* Load SCSI command packet. */
2871 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2872 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
2873 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2875 /* Set transfer direction. */
2876 dir = qla1280_data_direction(cmd);
2877 pkt->control_flags |= cpu_to_le16(dir);
2879 /* Set total data segment count. */
2880 pkt->dseg_count = cpu_to_le16(seg_cnt);
2883 * Load data segments.
2885 if (seg_cnt) { /* If data transfer. */
2886 struct scatterlist *sg, *s;
2887 int remseg = seg_cnt;
2889 sg = scsi_sglist(cmd);
2891 /* Setup packet address segment pointer. */
2892 dword_ptr = (u32 *)&pkt->dseg_0_address;
2894 /* Load command entry data segments. */
2895 for_each_sg(sg, s, seg_cnt, cnt) {
2899 dma_handle = sg_dma_address(s);
2900 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2901 if (ha->flags.use_pci_vchannel)
2902 sn_pci_set_vchan(ha->pdev,
2903 (unsigned long *)&dma_handle,
2907 cpu_to_le32(lower_32_bits(dma_handle));
2909 cpu_to_le32(upper_32_bits(dma_handle));
2910 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2911 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2912 cpu_to_le32(upper_32_bits(dma_handle)),
2913 cpu_to_le32(lower_32_bits(dma_handle)),
2914 cpu_to_le32(sg_dma_len(sg_next(s))));
2917 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2918 "command packet data - b %i, t %i, l %i \n",
2919 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2921 qla1280_dump_buffer(5, (char *)pkt,
2922 REQUEST_ENTRY_SIZE);
2925 * Build continuation packets.
2927 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2928 "remains\n", seg_cnt);
2930 while (remseg > 0) {
2931 /* Update sg start */
2933 /* Adjust ring index. */
2934 ha->req_ring_index++;
2935 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2936 ha->req_ring_index = 0;
2937 ha->request_ring_ptr =
2940 ha->request_ring_ptr++;
2942 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2944 /* Zero out packet. */
2945 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2947 /* Load packet defaults. */
2948 ((struct cont_a64_entry *) pkt)->entry_type =
2950 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2951 ((struct cont_a64_entry *) pkt)->sys_define =
2952 (uint8_t)ha->req_ring_index;
2953 /* Setup packet address segment pointer. */
2955 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2957 /* Load continuation entry data segments. */
2958 for_each_sg(sg, s, remseg, cnt) {
2961 dma_handle = sg_dma_address(s);
2962 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2963 if (ha->flags.use_pci_vchannel)
2964 sn_pci_set_vchan(ha->pdev,
2965 (unsigned long *)&dma_handle,
2969 cpu_to_le32(lower_32_bits(dma_handle));
2971 cpu_to_le32(upper_32_bits(dma_handle));
2973 cpu_to_le32(sg_dma_len(s));
2974 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2975 cpu_to_le32(upper_32_bits(dma_handle)),
2976 cpu_to_le32(lower_32_bits(dma_handle)),
2977 cpu_to_le32(sg_dma_len(s)));
2980 dprintk(5, "qla1280_64bit_start_scsi: "
2981 "continuation packet data - b %i, t "
2982 "%i, l %i \n", SCSI_BUS_32(cmd),
2983 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2984 qla1280_dump_buffer(5, (char *)pkt,
2985 REQUEST_ENTRY_SIZE);
2987 } else { /* No data transfer */
2988 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2989 "packet data - b %i, t %i, l %i \n",
2990 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2991 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2993 /* Adjust ring index. */
2994 ha->req_ring_index++;
2995 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2996 ha->req_ring_index = 0;
2997 ha->request_ring_ptr = ha->request_ring;
2999 ha->request_ring_ptr++;
3001 /* Set chip new ring index. */
3003 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3004 sp->flags |= SRB_SENT;
3006 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3010 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3012 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3016 #else /* !QLA_64BIT_PTR */
3019 * qla1280_32bit_start_scsi
3020 * The start SCSI is responsible for building request packets on
3021 * request ring and modifying ISP input pointer.
3023 * The Qlogic firmware interface allows every queue slot to have a SCSI
3024 * command and up to 4 scatter/gather (SG) entries. If we need more
3025 * than 4 SG entries, then continuation entries are used that can
3026 * hold another 7 entries each. The start routine determines if there
3027 * is eought empty slots then build the combination of requests to
3028 * fulfill the OS request.
3031 * ha = adapter block pointer.
3032 * sp = SCSI Request Block structure pointer.
3035 * 0 = success, was able to issue command.
3038 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
3040 struct device_reg __iomem *reg = ha->iobase;
3041 struct scsi_cmnd *cmd = sp->cmd;
3042 struct cmd_entry *pkt;
3050 ENTER("qla1280_32bit_start_scsi");
3052 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3055 /* Calculate number of entries and segments required. */
3057 seg_cnt = scsi_dma_map(cmd);
3060 * if greater than four sg entries then we need to allocate
3061 * continuation entries
3064 req_cnt += (seg_cnt - 4) / 7;
3065 if ((seg_cnt - 4) % 7)
3068 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3069 cmd, seg_cnt, req_cnt);
3070 } else if (seg_cnt < 0) {
3075 if ((req_cnt + 2) >= ha->req_q_cnt) {
3076 /* Calculate number of free request entries. */
3077 cnt = RD_REG_WORD(®->mailbox4);
3078 if (ha->req_ring_index < cnt)
3079 ha->req_q_cnt = cnt - ha->req_ring_index;
3082 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3085 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3086 ha->req_q_cnt, seg_cnt);
3087 /* If room for request in request ring. */
3088 if ((req_cnt + 2) >= ha->req_q_cnt) {
3089 status = SCSI_MLQUEUE_HOST_BUSY;
3090 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3091 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3092 ha->req_q_cnt, req_cnt);
3096 /* Check for empty slot in outstanding command list. */
3097 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3098 (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3100 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3101 status = SCSI_MLQUEUE_HOST_BUSY;
3102 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3103 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3107 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3108 ha->outstanding_cmds[cnt] = sp;
3109 ha->req_q_cnt -= req_cnt;
3112 * Build command packet.
3114 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3116 pkt->entry_type = COMMAND_TYPE;
3117 pkt->entry_count = (uint8_t) req_cnt;
3118 pkt->sys_define = (uint8_t) ha->req_ring_index;
3119 pkt->entry_status = 0;
3120 pkt->handle = cpu_to_le32(cnt);
3122 /* Zero out remaining portion of packet. */
3123 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3125 /* Set ISP command timeout. */
3126 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
3128 /* Set device target ID and LUN */
3129 pkt->lun = SCSI_LUN_32(cmd);
3130 pkt->target = SCSI_BUS_32(cmd) ?
3131 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3133 /* Enable simple tag queuing if device supports it. */
3134 if (cmd->device->simple_tags)
3135 pkt->control_flags |= cpu_to_le16(BIT_3);
3137 /* Load SCSI command packet. */
3138 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3139 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
3141 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3142 /* Set transfer direction. */
3143 dir = qla1280_data_direction(cmd);
3144 pkt->control_flags |= cpu_to_le16(dir);
3146 /* Set total data segment count. */
3147 pkt->dseg_count = cpu_to_le16(seg_cnt);
3150 * Load data segments.
3153 struct scatterlist *sg, *s;
3154 int remseg = seg_cnt;
3156 sg = scsi_sglist(cmd);
3158 /* Setup packet address segment pointer. */
3159 dword_ptr = &pkt->dseg_0_address;
3161 dprintk(3, "Building S/G data segments..\n");
3162 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3164 /* Load command entry data segments. */
3165 for_each_sg(sg, s, seg_cnt, cnt) {
3169 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3170 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3171 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3172 (lower_32_bits(sg_dma_address(s))),
3177 * Build continuation packets.
3179 dprintk(3, "S/G Building Continuation"
3180 "...seg_cnt=0x%x remains\n", seg_cnt);
3181 while (remseg > 0) {
3182 /* Continue from end point */
3184 /* Adjust ring index. */
3185 ha->req_ring_index++;
3186 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3187 ha->req_ring_index = 0;
3188 ha->request_ring_ptr =
3191 ha->request_ring_ptr++;
3193 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3195 /* Zero out packet. */
3196 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3198 /* Load packet defaults. */
3199 ((struct cont_entry *) pkt)->
3200 entry_type = CONTINUE_TYPE;
3201 ((struct cont_entry *) pkt)->entry_count = 1;
3203 ((struct cont_entry *) pkt)->sys_define =
3204 (uint8_t) ha->req_ring_index;
3206 /* Setup packet address segment pointer. */
3208 &((struct cont_entry *) pkt)->dseg_0_address;
3210 /* Load continuation entry data segments. */
3211 for_each_sg(sg, s, remseg, cnt) {
3215 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
3217 cpu_to_le32(sg_dma_len(s));
3219 "S/G Segment Cont. phys_addr=0x%x, "
3221 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
3222 cpu_to_le32(sg_dma_len(s)));
3225 dprintk(5, "qla1280_32bit_start_scsi: "
3226 "continuation packet data - "
3227 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3228 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3229 qla1280_dump_buffer(5, (char *)pkt,
3230 REQUEST_ENTRY_SIZE);
3232 } else { /* No data transfer at all */
3233 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3234 "packet data - \n");
3235 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3237 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3238 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3239 REQUEST_ENTRY_SIZE);
3241 /* Adjust ring index. */
3242 ha->req_ring_index++;
3243 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3244 ha->req_ring_index = 0;
3245 ha->request_ring_ptr = ha->request_ring;
3247 ha->request_ring_ptr++;
3249 /* Set chip new ring index. */
3250 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3251 "for pending command\n");
3252 sp->flags |= SRB_SENT;
3254 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3258 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3260 LEAVE("qla1280_32bit_start_scsi");
3268 * Function is responsible for locking ring and
3269 * getting a zeroed out request packet.
3272 * ha = adapter block pointer.
3275 * 0 = failed to get slot.
3278 qla1280_req_pkt(struct scsi_qla_host *ha)
3280 struct device_reg __iomem *reg = ha->iobase;
3281 request_t *pkt = NULL;
3285 ENTER("qla1280_req_pkt");
3288 * This can be called from interrupt context, damn it!!!
3290 /* Wait for 30 seconds for slot. */
3291 for (timer = 15000000; timer; timer--) {
3292 if (ha->req_q_cnt > 0) {
3293 /* Calculate number of free request entries. */
3294 cnt = RD_REG_WORD(®->mailbox4);
3295 if (ha->req_ring_index < cnt)
3296 ha->req_q_cnt = cnt - ha->req_ring_index;
3299 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3302 /* Found empty request ring slot? */
3303 if (ha->req_q_cnt > 0) {
3305 pkt = ha->request_ring_ptr;
3307 /* Zero out packet. */
3308 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3311 * How can this be right when we have a ring
3314 /* Set system defined field. */
3315 pkt->sys_define = (uint8_t) ha->req_ring_index;
3317 /* Set entry count. */
3318 pkt->entry_count = 1;
3325 /* Check for pending interrupts. */
3330 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3332 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3339 * Function is responsible for modifying ISP input pointer.
3340 * Releases ring lock.
3343 * ha = adapter block pointer.
3346 qla1280_isp_cmd(struct scsi_qla_host *ha)
3348 struct device_reg __iomem *reg = ha->iobase;
3350 ENTER("qla1280_isp_cmd");
3352 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3353 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3354 REQUEST_ENTRY_SIZE);
3356 /* Adjust ring index. */
3357 ha->req_ring_index++;
3358 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3359 ha->req_ring_index = 0;
3360 ha->request_ring_ptr = ha->request_ring;
3362 ha->request_ring_ptr++;
3365 * Update request index to mailbox4 (Request Queue In).
3367 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3369 LEAVE("qla1280_isp_cmd");
3372 /****************************************************************************/
3373 /* Interrupt Service Routine. */
3374 /****************************************************************************/
3376 /****************************************************************************
3378 * Calls I/O done on command completion.
3381 * ha = adapter block pointer.
3382 * done_q = done queue.
3383 ****************************************************************************/
3385 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3387 struct device_reg __iomem *reg = ha->iobase;
3388 struct response *pkt;
3389 struct srb *sp = NULL;
3390 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3395 ENTER("qla1280_isr");
3397 istatus = RD_REG_WORD(®->istatus);
3398 if (!(istatus & (RISC_INT | PCI_INT)))
3401 /* Save mailbox register 5 */
3402 mailbox[5] = RD_REG_WORD(®->mailbox5);
3404 /* Check for mailbox interrupt. */
3406 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3408 if (mailbox[0] & BIT_0) {
3409 /* Get mailbox data. */
3410 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3413 *wptr++ = RD_REG_WORD(®->mailbox0);
3414 *wptr++ = RD_REG_WORD(®->mailbox1);
3415 *wptr = RD_REG_WORD(®->mailbox2);
3416 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3418 *wptr++ = RD_REG_WORD(®->mailbox3);
3419 *wptr++ = RD_REG_WORD(®->mailbox4);
3421 *wptr++ = RD_REG_WORD(®->mailbox6);
3422 *wptr = RD_REG_WORD(®->mailbox7);
3425 /* Release mailbox registers. */
3427 WRT_REG_WORD(®->semaphore, 0);
3428 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3430 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3433 /* Handle asynchronous event */
3434 switch (mailbox[0]) {
3435 case MBA_SCSI_COMPLETION: /* Response completion */
3436 dprintk(5, "qla1280_isr: mailbox SCSI response "
3439 if (ha->flags.online) {
3440 /* Get outstanding command index. */
3441 index = mailbox[2] << 16 | mailbox[1];
3443 /* Validate handle. */
3444 if (index < MAX_OUTSTANDING_COMMANDS)
3445 sp = ha->outstanding_cmds[index];
3450 /* Free outstanding command slot. */
3451 ha->outstanding_cmds[index] = NULL;
3453 /* Save ISP completion status */
3454 CMD_RESULT(sp->cmd) = 0;
3455 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3457 /* Place block on done queue */
3458 list_add_tail(&sp->list, done_q);
3461 * If we get here we have a real problem!
3464 "qla1280: ISP invalid handle\n");
3469 case MBA_BUS_RESET: /* SCSI Bus Reset */
3470 ha->flags.reset_marker = 1;
3471 index = mailbox[6] & BIT_0;
3472 ha->bus_settings[index].reset_marker = 1;
3474 printk(KERN_DEBUG "qla1280_isr(): index %i "
3475 "asynchronous BUS_RESET\n", index);
3478 case MBA_SYSTEM_ERR: /* System Error */
3480 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3481 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3485 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3487 "qla1280: ISP Request Transfer Error\n");
3490 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3492 "qla1280: ISP Response Transfer Error\n");
3495 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3496 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3499 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3501 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3504 case MBA_DEVICE_RESET: /* Bus Device Reset */
3505 printk(KERN_INFO "qla1280_isr(): asynchronous "
3506 "BUS_DEVICE_RESET\n");
3508 ha->flags.reset_marker = 1;
3509 index = mailbox[6] & BIT_0;
3510 ha->bus_settings[index].reset_marker = 1;
3513 case MBA_BUS_MODE_CHANGE:
3515 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3519 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3520 if (mailbox[0] < MBA_ASYNC_EVENT) {
3522 memcpy((uint16_t *) ha->mailbox_out, wptr,
3523 MAILBOX_REGISTER_COUNT *
3526 if(ha->mailbox_wait != NULL)
3527 complete(ha->mailbox_wait);
3532 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3536 * We will receive interrupts during mailbox testing prior to
3537 * the card being marked online, hence the double check.
3539 if (!(ha->flags.online && !ha->mailbox_wait)) {
3540 dprintk(2, "qla1280_isr: Response pointer Error\n");
3544 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3547 while (ha->rsp_ring_index != mailbox[5]) {
3548 pkt = ha->response_ring_ptr;
3550 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3551 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3552 dprintk(5,"qla1280_isr: response packet data\n");
3553 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3555 if (pkt->entry_type == STATUS_TYPE) {
3556 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3557 || pkt->comp_status || pkt->entry_status) {
3558 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3559 "0x%x mailbox[5] = 0x%x, comp_status "
3560 "= 0x%x, scsi_status = 0x%x\n",
3561 ha->rsp_ring_index, mailbox[5],
3562 le16_to_cpu(pkt->comp_status),
3563 le16_to_cpu(pkt->scsi_status));
3566 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3567 "0x%x, mailbox[5] = 0x%x\n",
3568 ha->rsp_ring_index, mailbox[5]);
3569 dprintk(2, "qla1280_isr: response packet data\n");
3570 qla1280_dump_buffer(2, (char *)pkt,
3571 RESPONSE_ENTRY_SIZE);
3574 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3575 dprintk(2, "status: Cmd %p, handle %i\n",
3576 ha->outstanding_cmds[pkt->handle]->cmd,
3578 if (pkt->entry_type == STATUS_TYPE)
3579 qla1280_status_entry(ha, pkt, done_q);
3581 qla1280_error_entry(ha, pkt, done_q);
3582 /* Adjust ring index. */
3583 ha->rsp_ring_index++;
3584 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3585 ha->rsp_ring_index = 0;
3586 ha->response_ring_ptr = ha->response_ring;
3588 ha->response_ring_ptr++;
3589 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3594 LEAVE("qla1280_isr");
3599 * Processes asynchronous reset.
3602 * ha = adapter block pointer.
3605 qla1280_rst_aen(struct scsi_qla_host *ha)
3609 ENTER("qla1280_rst_aen");
3611 if (ha->flags.online && !ha->flags.reset_active &&
3612 !ha->flags.abort_isp_active) {
3613 ha->flags.reset_active = 1;
3614 while (ha->flags.reset_marker) {
3615 /* Issue marker command. */
3616 ha->flags.reset_marker = 0;
3617 for (bus = 0; bus < ha->ports &&
3618 !ha->flags.reset_marker; bus++) {
3619 if (ha->bus_settings[bus].reset_marker) {
3620 ha->bus_settings[bus].reset_marker = 0;
3621 qla1280_marker(ha, bus, 0, 0,
3628 LEAVE("qla1280_rst_aen");
3633 * qla1280_status_entry
3634 * Processes received ISP status entry.
3637 * ha = adapter block pointer.
3638 * pkt = entry pointer.
3639 * done_q = done queue.
3642 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3643 struct list_head *done_q)
3645 unsigned int bus, target, lun;
3648 struct scsi_cmnd *cmd;
3649 uint32_t handle = le32_to_cpu(pkt->handle);
3650 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3651 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3653 ENTER("qla1280_status_entry");
3655 /* Validate handle. */
3656 if (handle < MAX_OUTSTANDING_COMMANDS)
3657 sp = ha->outstanding_cmds[handle];
3662 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3666 /* Free outstanding command slot. */
3667 ha->outstanding_cmds[handle] = NULL;
3671 /* Generate LU queue on cntrl, target, LUN */
3672 bus = SCSI_BUS_32(cmd);
3673 target = SCSI_TCN_32(cmd);
3674 lun = SCSI_LUN_32(cmd);
3676 if (comp_status || scsi_status) {
3677 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3678 "0x%x, handle = 0x%x\n", comp_status,
3679 scsi_status, handle);
3682 /* Target busy or queue full */
3683 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3684 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3685 CMD_RESULT(cmd) = scsi_status & 0xff;
3688 /* Save ISP completion status */
3689 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3691 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3692 if (comp_status != CS_ARS_FAILED) {
3693 uint16_t req_sense_length =
3694 le16_to_cpu(pkt->req_sense_length);
3695 if (req_sense_length < CMD_SNSLEN(cmd))
3696 sense_sz = req_sense_length;
3699 * scsi_cmnd->sense_buffer is
3700 * 64 bytes, why only copy 63?
3701 * This looks wrong! /Jes
3703 sense_sz = CMD_SNSLEN(cmd) - 1;
3705 memcpy(cmd->sense_buffer,
3706 &pkt->req_sense_data, sense_sz);
3709 memset(cmd->sense_buffer + sense_sz, 0,
3710 SCSI_SENSE_BUFFERSIZE - sense_sz);
3712 dprintk(2, "qla1280_status_entry: Check "
3713 "condition Sense data, b %i, t %i, "
3714 "l %i\n", bus, target, lun);
3716 qla1280_dump_buffer(2,
3717 (char *)cmd->sense_buffer,
3722 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3724 /* Place command on done queue. */
3725 list_add_tail(&sp->list, done_q);
3727 LEAVE("qla1280_status_entry");
3731 * qla1280_error_entry
3732 * Processes error entry.
3735 * ha = adapter block pointer.
3736 * pkt = entry pointer.
3737 * done_q = done queue.
3740 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3741 struct list_head *done_q)
3744 uint32_t handle = le32_to_cpu(pkt->handle);
3746 ENTER("qla1280_error_entry");
3748 if (pkt->entry_status & BIT_3)
3749 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3750 else if (pkt->entry_status & BIT_2)
3751 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3752 else if (pkt->entry_status & BIT_1)
3753 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3755 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3757 /* Validate handle. */
3758 if (handle < MAX_OUTSTANDING_COMMANDS)
3759 sp = ha->outstanding_cmds[handle];
3764 /* Free outstanding command slot. */
3765 ha->outstanding_cmds[handle] = NULL;
3767 /* Bad payload or header */
3768 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3769 /* Bad payload or header, set error status. */
3770 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3771 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3772 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3773 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3775 /* Set error status. */
3776 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3779 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3781 /* Place command on done queue. */
3782 list_add_tail(&sp->list, done_q);
3784 #ifdef QLA_64BIT_PTR
3785 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3786 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3790 LEAVE("qla1280_error_entry");
3795 * Resets ISP and aborts all outstanding commands.
3798 * ha = adapter block pointer.
3804 qla1280_abort_isp(struct scsi_qla_host *ha)
3806 struct device_reg __iomem *reg = ha->iobase;
3812 ENTER("qla1280_abort_isp");
3814 if (ha->flags.abort_isp_active || !ha->flags.online)
3817 ha->flags.abort_isp_active = 1;
3819 /* Disable ISP interrupts. */
3820 qla1280_disable_intrs(ha);
3821 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3822 RD_REG_WORD(®->id_l);
3824 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3826 /* Dequeue all commands in outstanding command list. */
3827 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3828 struct scsi_cmnd *cmd;
3829 sp = ha->outstanding_cmds[cnt];
3832 CMD_RESULT(cmd) = DID_RESET << 16;
3833 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
3834 ha->outstanding_cmds[cnt] = NULL;
3835 list_add_tail(&sp->list, &ha->done_q);
3841 status = qla1280_load_firmware(ha);
3845 /* Setup adapter based on NVRAM parameters. */
3846 qla1280_nvram_config (ha);
3848 status = qla1280_init_rings(ha);
3852 /* Issue SCSI reset. */
3853 for (bus = 0; bus < ha->ports; bus++)
3854 qla1280_bus_reset(ha, bus);
3856 ha->flags.abort_isp_active = 0;
3860 "qla1280: ISP error recovery failed, board disabled");
3861 qla1280_reset_adapter(ha);
3862 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3865 LEAVE("qla1280_abort_isp");
3871 * qla1280_debounce_register
3872 * Debounce register.
3875 * port = register address.
3881 qla1280_debounce_register(volatile u16 __iomem * addr)
3886 ret = RD_REG_WORD(addr);
3887 ret2 = RD_REG_WORD(addr);
3894 ret = RD_REG_WORD(addr);
3895 ret2 = RD_REG_WORD(addr);
3896 } while (ret != ret2);
3902 /************************************************************************
3903 * qla1280_check_for_dead_scsi_bus *
3905 * This routine checks for a dead SCSI bus *
3906 ************************************************************************/
3907 #define SET_SXP_BANK 0x0100
3908 #define SCSI_PHASE_INVALID 0x87FF
3910 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3912 uint16_t config_reg, scsi_control;
3913 struct device_reg __iomem *reg = ha->iobase;
3915 if (ha->bus_settings[bus].scsi_bus_dead) {
3916 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
3917 config_reg = RD_REG_WORD(®->cfg_1);
3918 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
3919 scsi_control = RD_REG_WORD(®->scsiControlPins);
3920 WRT_REG_WORD(®->cfg_1, config_reg);
3921 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
3923 if (scsi_control == SCSI_PHASE_INVALID) {
3924 ha->bus_settings[bus].scsi_bus_dead = 1;
3925 return 1; /* bus is dead */
3927 ha->bus_settings[bus].scsi_bus_dead = 0;
3928 ha->bus_settings[bus].failed_reset_count = 0;
3931 return 0; /* bus is not dead */
3935 qla1280_get_target_parameters(struct scsi_qla_host *ha,
3936 struct scsi_device *device)
3938 uint16_t mb[MAILBOX_REGISTER_COUNT];
3939 int bus, target, lun;
3941 bus = device->channel;
3942 target = device->id;
3946 mb[0] = MBC_GET_TARGET_PARAMETERS;
3947 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3949 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3952 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3955 printk(" Sync: period %d, offset %d",
3956 (mb[3] & 0xff), (mb[3] >> 8));
3959 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3964 if (device->simple_tags)
3965 printk(", Tagged queuing: depth %d", device->queue_depth);
3972 __qla1280_dump_buffer(char *b, int size)
3977 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3978 "Bh Ch Dh Eh Fh\n");
3979 printk(KERN_DEBUG "---------------------------------------------"
3980 "------------------\n");
3982 for (cnt = 0; cnt < size;) {
3985 printk("0x%02x", c);
3996 /**************************************************************************
3997 * ql1280_print_scsi_cmd
3999 **************************************************************************/
4001 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
4003 struct scsi_qla_host *ha;
4004 struct Scsi_Host *host = CMD_HOST(cmd);
4006 /* struct scatterlist *sg; */
4009 ha = (struct scsi_qla_host *)host->hostdata;
4011 sp = (struct srb *)CMD_SP(cmd);
4012 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
4013 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4014 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
4017 for (i = 0; i < cmd->cmd_len; i++) {
4018 printk("0x%02x ", cmd->cmnd[i]);
4020 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
4021 printk(" request buffer=0x%p, request buffer len=0x%x\n",
4022 scsi_sglist(cmd), scsi_bufflen(cmd));
4025 sg = (struct scatterlist *) cmd->request_buffer;
4026 printk(" SG buffer: \n");
4027 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4029 printk(" tag=%d, transfersize=0x%x \n",
4030 cmd->tag, cmd->transfersize);
4031 printk(" SP=0x%p\n", CMD_SP(cmd));
4032 printk(" underflow size = 0x%x, direction=0x%x\n",
4033 cmd->underflow, cmd->sc_data_direction);
4036 /**************************************************************************
4037 * ql1280_dump_device
4039 **************************************************************************/
4041 ql1280_dump_device(struct scsi_qla_host *ha)
4044 struct scsi_cmnd *cp;
4048 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4050 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4051 if ((sp = ha->outstanding_cmds[i]) == NULL)
4053 if ((cp = sp->cmd) == NULL)
4055 qla1280_print_scsi_cmd(1, cp);
4070 struct setup_tokens {
4075 static struct setup_tokens setup_token[] __initdata =
4077 { "nvram", TOKEN_NVRAM },
4078 { "sync", TOKEN_SYNC },
4079 { "wide", TOKEN_WIDE },
4080 { "ppr", TOKEN_PPR },
4081 { "verbose", TOKEN_VERBOSE },
4082 { "debug", TOKEN_DEBUG },
4086 /**************************************************************************
4089 * Handle boot parameters. This really needs to be changed so one
4090 * can specify per adapter parameters.
4091 **************************************************************************/
4093 qla1280_setup(char *s)
4101 while (cp && (ptr = strchr(cp, ':'))) {
4103 if (!strcmp(ptr, "yes")) {
4106 } else if (!strcmp(ptr, "no")) {
4110 val = simple_strtoul(ptr, &ptr, 0);
4112 switch ((toke = qla1280_get_token(cp))) {
4115 driver_setup.no_nvram = 1;
4119 driver_setup.no_sync = 1;
4120 else if (val != 0x10000)
4121 driver_setup.sync_mask = val;
4125 driver_setup.no_wide = 1;
4126 else if (val != 0x10000)
4127 driver_setup.wide_mask = val;
4131 driver_setup.no_ppr = 1;
4132 else if (val != 0x10000)
4133 driver_setup.ppr_mask = val;
4136 qla1280_verbose = val;
4139 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4143 cp = strchr(ptr, ';');
4155 qla1280_get_token(char *str)
4161 sep = strchr(str, ':');
4164 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
4165 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4166 ret = setup_token[i].val;
4176 static struct scsi_host_template qla1280_driver_template = {
4177 .module = THIS_MODULE,
4178 .proc_name = "qla1280",
4179 .name = "Qlogic ISP 1280/12160",
4180 .info = qla1280_info,
4181 .slave_configure = qla1280_slave_configure,
4182 .queuecommand = qla1280_queuecommand,
4183 .eh_abort_handler = qla1280_eh_abort,
4184 .eh_device_reset_handler= qla1280_eh_device_reset,
4185 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4186 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4187 .bios_param = qla1280_biosparam,
4188 .can_queue = MAX_OUTSTANDING_COMMANDS,
4190 .sg_tablesize = SG_ALL,
4195 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4197 int devnum = id->driver_data;
4198 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4199 struct Scsi_Host *host;
4200 struct scsi_qla_host *ha;
4201 int error = -ENODEV;
4203 /* Bypass all AMI SUBSYS VENDOR IDs */
4204 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4206 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4210 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4211 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4213 if (pci_enable_device(pdev)) {
4215 "qla1280: Failed to enabled pci device, aborting.\n");
4219 pci_set_master(pdev);
4222 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4225 "qla1280: Failed to register host, aborting.\n");
4226 goto error_disable_device;
4229 ha = (struct scsi_qla_host *)host->hostdata;
4230 memset(ha, 0, sizeof(struct scsi_qla_host));
4233 ha->devnum = devnum; /* specifies microcode load address */
4235 #ifdef QLA_64BIT_PTR
4236 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
4237 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4238 printk(KERN_WARNING "scsi(%li): Unable to set a "
4239 "suitable DMA mask - aborting\n", ha->host_no);
4241 goto error_put_host;
4244 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4247 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
4248 printk(KERN_WARNING "scsi(%li): Unable to set a "
4249 "suitable DMA mask - aborting\n", ha->host_no);
4251 goto error_put_host;
4255 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
4256 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4257 &ha->request_dma, GFP_KERNEL);
4258 if (!ha->request_ring) {
4259 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4260 goto error_put_host;
4263 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
4264 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4265 &ha->response_dma, GFP_KERNEL);
4266 if (!ha->response_ring) {
4267 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4268 goto error_free_request_ring;
4271 ha->ports = bdp->numPorts;
4274 ha->host_no = host->host_no;
4276 host->irq = pdev->irq;
4277 host->max_channel = bdp->numPorts - 1;
4278 host->max_lun = MAX_LUNS - 1;
4279 host->max_id = MAX_TARGETS;
4280 host->max_sectors = 1024;
4281 host->unique_id = host->host_no;
4285 #if MEMORY_MAPPED_IO
4286 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
4288 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4289 goto error_free_response_ring;
4292 host->base = (unsigned long)ha->mmpbase;
4293 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4295 host->io_port = pci_resource_start(ha->pdev, 0);
4296 if (!request_region(host->io_port, 0xff, "qla1280")) {
4297 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4298 "0x%04lx-0x%04lx - already in use\n",
4299 host->io_port, host->io_port + 0xff);
4300 goto error_free_response_ring;
4303 ha->iobase = (struct device_reg *)host->io_port;
4306 INIT_LIST_HEAD(&ha->done_q);
4308 /* Disable ISP interrupts. */
4309 qla1280_disable_intrs(ha);
4311 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
4313 printk("qla1280 : Failed to reserve interrupt %d already "
4314 "in use\n", pdev->irq);
4315 goto error_release_region;
4318 /* load the F/W, read paramaters, and init the H/W */
4319 if (qla1280_initialize_adapter(ha)) {
4320 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4321 goto error_free_irq;
4324 /* set our host ID (need to do something about our two IDs) */
4325 host->this_id = ha->bus_settings[0].id;
4327 pci_set_drvdata(pdev, host);
4329 error = scsi_add_host(host, &pdev->dev);
4331 goto error_disable_adapter;
4332 scsi_scan_host(host);
4336 error_disable_adapter:
4337 qla1280_disable_intrs(ha);
4339 free_irq(pdev->irq, ha);
4340 error_release_region:
4341 #if MEMORY_MAPPED_IO
4342 iounmap(ha->mmpbase);
4344 release_region(host->io_port, 0xff);
4346 error_free_response_ring:
4347 dma_free_coherent(&ha->pdev->dev,
4348 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4349 ha->response_ring, ha->response_dma);
4350 error_free_request_ring:
4351 dma_free_coherent(&ha->pdev->dev,
4352 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4353 ha->request_ring, ha->request_dma);
4355 scsi_host_put(host);
4356 error_disable_device:
4357 pci_disable_device(pdev);
4364 qla1280_remove_one(struct pci_dev *pdev)
4366 struct Scsi_Host *host = pci_get_drvdata(pdev);
4367 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4369 scsi_remove_host(host);
4371 qla1280_disable_intrs(ha);
4373 free_irq(pdev->irq, ha);
4375 #if MEMORY_MAPPED_IO
4376 iounmap(ha->mmpbase);
4378 release_region(host->io_port, 0xff);
4381 dma_free_coherent(&ha->pdev->dev,
4382 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4383 ha->request_ring, ha->request_dma);
4384 dma_free_coherent(&ha->pdev->dev,
4385 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4386 ha->response_ring, ha->response_dma);
4388 pci_disable_device(pdev);
4390 scsi_host_put(host);
4393 static struct pci_driver qla1280_pci_driver = {
4395 .id_table = qla1280_pci_tbl,
4396 .probe = qla1280_probe_one,
4397 .remove = qla1280_remove_one,
4403 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4405 "qla1280: struct srb too big, aborting\n");
4411 * If we are called as a module, the qla1280 pointer may not be null
4412 * and it would point to our bootup string, just like on the lilo
4413 * command line. IF not NULL, then process this config string with
4417 * To add options at boot time add a line to your lilo.conf file like:
4418 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4419 * which will result in the first four devices on the first two
4420 * controllers being set to a tagged queue depth of 32.
4423 qla1280_setup(qla1280);
4426 return pci_register_driver(&qla1280_pci_driver);
4434 pci_unregister_driver(&qla1280_pci_driver);
4435 /* release any allocated firmware images */
4436 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4437 release_firmware(qla1280_fw_tbl[i].fw);
4438 qla1280_fw_tbl[i].fw = NULL;
4442 module_init(qla1280_init);
4443 module_exit(qla1280_exit);
4445 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4446 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4447 MODULE_LICENSE("GPL");
4448 MODULE_FIRMWARE("qlogic/1040.bin");
4449 MODULE_FIRMWARE("qlogic/1280.bin");
4450 MODULE_FIRMWARE("qlogic/12160.bin");
4451 MODULE_VERSION(QLA1280_VERSION);
4454 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4455 * Emacs will notice this stuff at the end of the file and automatically
4456 * adjust the settings for this buffer only. This must remain at the end
4458 * ---------------------------------------------------------------------------