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.25"
21 /*****************************************************************************
23 Rev 3.25.1, February 10, 2005 Christoph Hellwig
24 - use pci_map_single to map non-S/G requests
25 - remove qla1280_proc_info
26 Rev 3.25, September 28, 2004, Christoph Hellwig
27 - add support for ISP1020/1040
28 - don't include "scsi.h" anymore for 2.6.x
29 Rev 3.24.4 June 7, 2004 Christoph Hellwig
30 - restructure firmware loading, cleanup initialization code
31 - prepare support for ISP1020/1040 chips
32 Rev 3.24.3 January 19, 2004, Jes Sorensen
33 - Handle PCI DMA mask settings correctly
34 - Correct order of error handling in probe_one, free_irq should not
35 be called if request_irq failed
36 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
37 - Big endian fixes (James)
38 - Remove bogus IOCB content on zero data transfer commands (Andrew)
39 Rev 3.24.1 January 5, 2004, Jes Sorensen
40 - Initialize completion queue to avoid OOPS on probe
41 - Handle interrupts during mailbox testing
42 Rev 3.24 November 17, 2003, Christoph Hellwig
43 - use struct list_head for completion queue
44 - avoid old Scsi_FOO typedefs
45 - cleanup 2.4 compat glue a bit
46 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
47 - make initialization for memory mapped vs port I/O more similar
48 - remove broken pci config space manipulation
50 - this is an almost perfect 2.6 scsi driver now! ;)
51 Rev 3.23.39 December 17, 2003, Jes Sorensen
52 - Delete completion queue from srb if mailbox command failed to
53 to avoid qla1280_done completeting qla1280_error_action's
55 - Reduce arguments for qla1280_done
56 Rev 3.23.38 October 18, 2003, Christoph Hellwig
57 - Convert to new-style hotplugable driver for 2.6
58 - Fix missing scsi_unregister/scsi_host_put on HBA removal
59 - Kill some more cruft
60 Rev 3.23.37 October 1, 2003, Jes Sorensen
61 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
63 - Clean up locking in probe path
64 Rev 3.23.36 October 1, 2003, Christoph Hellwig
65 - queuecommand only ever receives new commands - clear flags
66 - Reintegrate lost fixes from Linux 2.5
67 Rev 3.23.35 August 14, 2003, Jes Sorensen
69 Rev 3.23.34 July 23, 2003, Jes Sorensen
70 - Remove pointless TRUE/FALSE macros
71 - Clean up vchan handling
72 Rev 3.23.33 July 3, 2003, Jes Sorensen
73 - Don't define register access macros before define determining MMIO.
74 This just happend to work out on ia64 but not elsewhere.
75 - Don't try and read from the card while it is in reset as
76 it won't respond and causes an MCA
77 Rev 3.23.32 June 23, 2003, Jes Sorensen
78 - Basic support for boot time arguments
79 Rev 3.23.31 June 8, 2003, Jes Sorensen
80 - Reduce boot time messages
81 Rev 3.23.30 June 6, 2003, Jes Sorensen
82 - Do not enable sync/wide/ppr before it has been determined
83 that the target device actually supports it
84 - Enable DMA arbitration for multi channel controllers
85 Rev 3.23.29 June 3, 2003, Jes Sorensen
87 Rev 3.23.28 June 3, 2003, Jes Sorensen
88 - Eliminate duplicate marker commands on bus resets
89 - Handle outstanding commands appropriately on bus/device resets
90 Rev 3.23.27 May 28, 2003, Jes Sorensen
91 - Remove bogus input queue code, let the Linux SCSI layer do the work
92 - Clean up NVRAM handling, only read it once from the card
93 - Add a number of missing default nvram parameters
94 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
95 - Use completion queue for mailbox commands instead of busy wait
96 Rev 3.23.25 Beta May 27, 2003, James Bottomley
97 - Migrate to use new error handling code
98 Rev 3.23.24 Beta May 21, 2003, James Bottomley
100 - Cleanup data direction code
101 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
102 - Switch to using MMIO instead of PIO
103 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
104 - Fix PCI parity problem with 12160 during reset.
105 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
106 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
107 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
108 - Remove < 2.4.x support
109 - Introduce HOST_LOCK to make the spin lock changes portable.
110 - Remove a bunch of idiotic and unnecessary typedef's
111 - Kill all leftovers of target-mode support which never worked anyway
112 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
113 - Do qla1280_pci_config() before calling request_irq() and
115 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
117 - Hand correct arguments to free_irq() in case of failure
118 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
119 - Run source through Lindent and clean up the output
120 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
121 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
122 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
123 - Rely on mailbox commands generating interrupts - do not
124 run qla1280_isr() from ql1280_mailbox_command()
125 - Remove device_reg_t
126 - Integrate ql12160_set_target_parameters() with 1280 version
127 - Make qla1280_setup() non static
128 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
129 sent to the card - this command pauses the firmare!!!
130 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
131 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
132 - Remove a pile of pointless and confusing (srb_t **) and
133 (scsi_lu_t *) typecasts
134 - Explicit mark that we do not use the new error handling (for now)
135 - Remove scsi_qla_host_t and use 'struct' instead
136 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
137 pci_64bit_slot flags which weren't used for anything anyway
138 - Grab host->host_lock while calling qla1280_isr() from abort()
139 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
140 do not need to save/restore flags in the interrupt handler
141 - Enable interrupts early (before any mailbox access) in preparation
142 for cleaning up the mailbox handling
143 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
144 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
145 it with proper use of dprintk().
146 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
147 a debug level argument to determine if data is to be printed
148 - Add KERN_* info to printk()
149 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
150 - Significant cosmetic cleanups
151 - Change debug code to use dprintk() and remove #if mess
152 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
153 - More cosmetic cleanups, fix places treating return as function
154 - use cpu_relax() in qla1280_debounce_register()
155 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
156 - Make it compile under 2.5.5
157 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
158 - Do no typecast short * to long * in QL1280BoardTbl, this
159 broke miserably on big endian boxes
160 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
161 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
162 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
163 unsigned int to match the types from struct scsi_cmnd
164 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
165 - Remove bogus timer_t typedef from qla1280.h
166 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
167 for PCI_ values, call pci_set_master()
168 - Fix memleak of qla1280_buffer on module unload
169 - Only compile module parsing code #ifdef MODULE - should be
170 changed to use individual MODULE_PARM's later
171 - Remove dummy_buffer that was never modified nor printed
172 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
173 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
174 - Remove \r from print statements, this is Linux, not DOS
175 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
177 - Remove C++ compile hack in header file as Linux driver are not
178 supposed to be compiled as C++
179 - Kill MS_64BITS macro as it makes the code more readable
180 - Remove unnecessary flags.in_interrupts bit
181 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
182 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
183 - Check whether the interrupt was generated by the QLA1280 before
185 - qla1280_status_entry(): Only zero out part of sense_buffer that
186 is not being copied into
187 - Remove more superflouous typecasts
188 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
189 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
190 - Don't walk the entire list in qla1280_putq_t() just to directly
191 grab the pointer to the last element afterwards
192 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
193 - Don't use SA_INTERRUPT, it's use is deprecated for this kinda driver
194 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
195 - Set dev->max_sectors to 1024
196 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
197 - Provide compat macros for pci_enable_device(), pci_find_subsys()
198 and scsi_set_pci_device()
199 - Call scsi_set_pci_device() for all devices
200 - Reduce size of kernel version dependent device probe code
201 - Move duplicate probe/init code to separate function
202 - Handle error if qla1280_mem_alloc() fails
203 - Kill OFFSET() macro and use Linux's PCI definitions instead
204 - Kill private structure defining PCI config space (struct config_reg)
205 - Only allocate I/O port region if not in MMIO mode
206 - Remove duplicate (unused) sanity check of sife of srb_t
207 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
208 - Change home-brew memset() implementations to use memset()
209 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
210 port directly is not legal under Linux.
211 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
212 - Remove pre 2.2 kernel support
213 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
214 - Fix MMIO access to use readl/writel instead of directly
215 dereferencing pointers
216 - Nuke MSDOS debugging code
217 - Change true/false data types to int from uint8_t
218 - Use int for counters instead of uint8_t etc.
219 - Clean up size & byte order conversion macro usage
220 Rev 3.23 Beta January 11, 2001 BN Qlogic
221 - Added check of device_id when handling non
222 QLA12160s during detect().
223 Rev 3.22 Beta January 5, 2001 BN Qlogic
224 - Changed queue_task() to schedule_task()
225 for kernels 2.4.0 and higher.
226 Note: 2.4.0-testxx kernels released prior to
227 the actual 2.4.0 kernel release on January 2001
228 will get compile/link errors with schedule_task().
229 Please update your kernel to released 2.4.0 level,
230 or comment lines in this file flagged with 3.22
231 to resolve compile/link error of schedule_task().
232 - Added -DCONFIG_SMP in addition to -D__SMP__
233 in Makefile for 2.4.0 builds of driver as module.
234 Rev 3.21 Beta January 4, 2001 BN Qlogic
235 - Changed criteria of 64/32 Bit mode of HBA
236 operation according to BITS_PER_LONG rather
237 than HBA's NVRAM setting of >4Gig memory bit;
238 so that the HBA auto-configures without the need
239 to setup each system individually.
240 Rev 3.20 Beta December 5, 2000 BN Qlogic
241 - Added priority handling to IA-64 onboard SCSI
242 ISP12160 chip for kernels greater than 2.3.18.
243 - Added irqrestore for qla1280_intr_handler.
244 - Enabled /proc/scsi/qla1280 interface.
245 - Clear /proc/scsi/qla1280 counters in detect().
246 Rev 3.19 Beta October 13, 2000 BN Qlogic
247 - Declare driver_template for new kernel
248 (2.4.0 and greater) scsi initialization scheme.
249 - Update /proc/scsi entry for 2.3.18 kernels and
251 Rev 3.18 Beta October 10, 2000 BN Qlogic
252 - Changed scan order of adapters to map
253 the QLA12160 followed by the QLA1280.
254 Rev 3.17 Beta September 18, 2000 BN Qlogic
255 - Removed warnings for 32 bit 2.4.x compiles
256 - Corrected declared size for request and response
257 DMA addresses that are kept in each ha
258 Rev. 3.16 Beta August 25, 2000 BN Qlogic
259 - Corrected 64 bit addressing issue on IA-64
260 where the upper 32 bits were not properly
261 passed to the RISC engine.
262 Rev. 3.15 Beta August 22, 2000 BN Qlogic
263 - Modified qla1280_setup_chip to properly load
264 ISP firmware for greater that 4 Gig memory on IA-64
265 Rev. 3.14 Beta August 16, 2000 BN Qlogic
266 - Added setting of dma_mask to full 64 bit
267 if flags.enable_64bit_addressing is set in NVRAM
268 Rev. 3.13 Beta August 16, 2000 BN Qlogic
269 - Use new PCI DMA mapping APIs for 2.4.x kernel
270 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
271 - Added check of pci_enable_device to detect() for 2.3.x
272 - Use pci_resource_start() instead of
273 pdev->resource[0].start in detect() for 2.3.x
274 - Updated driver version
275 Rev. 3.11 July 14, 2000 BN Qlogic
276 - Updated SCSI Firmware to following versions:
279 - Updated driver version to 3.11
280 Rev. 3.10 June 23, 2000 BN Qlogic
281 - Added filtering of AMI SubSys Vendor ID devices
283 - DEBUG_QLA1280 undefined and new version BN Qlogic
284 Rev. 3.08b May 9, 2000 MD Dell
285 - Added logic to check against AMI subsystem vendor ID
286 Rev. 3.08 May 4, 2000 DG Qlogic
287 - Added logic to check for PCI subsystem ID.
288 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
289 - Updated SCSI Firmware to following versions:
292 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
293 - Internal revision; not released
294 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
295 - Edit correction for virt_to_bus and PROC.
296 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
297 - Merge changes from ia64 port.
298 Rev. 3.03 Mar 28, 2000 BN Qlogic
299 - Increase version to reflect new code drop with compile fix
300 of issue with inclusion of linux/spinlock for 2.3 kernels
301 Rev. 3.02 Mar 15, 2000 BN Qlogic
302 - Merge qla1280_proc_info from 2.10 code base
303 Rev. 3.01 Feb 10, 2000 BN Qlogic
304 - Corrected code to compile on a 2.2.x kernel.
305 Rev. 3.00 Jan 17, 2000 DG Qlogic
306 - Added 64-bit support.
307 Rev. 2.07 Nov 9, 1999 DG Qlogic
308 - Added new routine to set target parameters for ISP12160.
309 Rev. 2.06 Sept 10, 1999 DG Qlogic
310 - Added support for ISP12160 Ultra 3 chip.
311 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
312 - Modified code to remove errors generated when compiling with
313 Cygnus IA64 Compiler.
314 - Changed conversion of pointers to unsigned longs instead of integers.
315 - Changed type of I/O port variables from uint32_t to unsigned long.
316 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
317 - Changed sprintf and printk format specifiers for pointers to %p.
318 - Changed some int to long type casts where needed in sprintf & printk.
319 - Added l modifiers to sprintf and printk format specifiers for longs.
320 - Removed unused local variables.
321 Rev. 1.20 June 8, 1999 DG, Qlogic
322 Changes to support RedHat release 6.0 (kernel 2.2.5).
323 - Added SCSI exclusive access lock (io_request_lock) when accessing
325 - Added changes for the new LINUX interface template. Some new error
326 handling routines have been added to the template, but for now we
327 will use the old ones.
328 - Initial Beta Release.
329 *****************************************************************************/
332 #include <linux/config.h>
333 #include <linux/module.h>
335 #include <linux/version.h>
336 #include <linux/types.h>
337 #include <linux/string.h>
338 #include <linux/errno.h>
339 #include <linux/kernel.h>
340 #include <linux/ioport.h>
341 #include <linux/delay.h>
342 #include <linux/timer.h>
343 #include <linux/sched.h>
344 #include <linux/pci.h>
345 #include <linux/proc_fs.h>
346 #include <linux/stat.h>
347 #include <linux/slab.h>
348 #include <linux/pci_ids.h>
349 #include <linux/interrupt.h>
350 #include <linux/init.h>
354 #include <asm/byteorder.h>
355 #include <asm/processor.h>
356 #include <asm/types.h>
357 #include <asm/system.h>
359 #if LINUX_VERSION_CODE >= 0x020545
360 #include <scsi/scsi.h>
361 #include <scsi/scsi_cmnd.h>
362 #include <scsi/scsi_device.h>
363 #include <scsi/scsi_host.h>
364 #include <scsi/scsi_tcq.h>
366 #include <linux/blk.h>
368 #include <scsi/scsi_host.h>
372 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
373 #include <asm/sn/io.h>
376 #if LINUX_VERSION_CODE < 0x020407
377 #error "Kernels older than 2.4.7 are no longer supported"
382 * Compile time Options:
383 * 0 - Disable and 1 - Enable
385 #define DEBUG_QLA1280_INTR 0
386 #define DEBUG_PRINT_NVRAM 0
387 #define DEBUG_QLA1280 0
390 * The SGI VISWS is broken and doesn't support MMIO ;-(
392 #ifdef CONFIG_X86_VISWS
393 #define MEMORY_MAPPED_IO 0
395 #define MEMORY_MAPPED_IO 1
398 #define UNIQUE_FW_NAME
400 #include "ql12160_fw.h" /* ISP RISC codes */
401 #include "ql1280_fw.h"
402 #include "ql1040_fw.h"
408 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1080
409 #define PCI_DEVICE_ID_QLOGIC_ISP1080 0x1080
411 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1240
412 #define PCI_DEVICE_ID_QLOGIC_ISP1240 0x1240
414 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1280
415 #define PCI_DEVICE_ID_QLOGIC_ISP1280 0x1280
417 #ifndef PCI_DEVICE_ID_QLOGIC_ISP10160
418 #define PCI_DEVICE_ID_QLOGIC_ISP10160 0x1016
420 #ifndef PCI_DEVICE_ID_QLOGIC_ISP12160
421 #define PCI_DEVICE_ID_QLOGIC_ISP12160 0x1216
424 #ifndef PCI_VENDOR_ID_AMI
425 #define PCI_VENDOR_ID_AMI 0x101e
428 #ifndef BITS_PER_LONG
429 #error "BITS_PER_LONG not defined!"
431 #if (BITS_PER_LONG == 64) || defined CONFIG_HIGHMEM
432 #define QLA_64BIT_PTR 1
436 #define pci_dma_hi32(a) ((a >> 16) >> 16)
438 #define pci_dma_hi32(a) 0
440 #define pci_dma_lo32(a) (a & 0xffffffff)
442 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */
444 #if LINUX_VERSION_CODE < 0x020500
445 #define HOST_LOCK &io_request_lock
446 #define irqreturn_t void
447 #define IRQ_RETVAL(foo)
448 #define MSG_ORDERED_TAG 1
450 #define DMA_BIDIRECTIONAL SCSI_DATA_UNKNOWN
451 #define DMA_TO_DEVICE SCSI_DATA_WRITE
452 #define DMA_FROM_DEVICE SCSI_DATA_READ
453 #define DMA_NONE SCSI_DATA_NONE
455 #ifndef HAVE_SECTOR_T
456 typedef unsigned int sector_t;
460 scsi_adjust_queue_depth(struct scsi_device *device, int tag, int depth)
463 device->tagged_queue = tag;
464 device->current_tag = 0;
466 device->queue_depth = depth;
468 static inline struct Scsi_Host *scsi_host_alloc(Scsi_Host_Template *t, size_t s)
470 return scsi_register(t, s);
472 static inline void scsi_host_put(struct Scsi_Host *h)
477 #define HOST_LOCK ha->host->host_lock
479 #if LINUX_VERSION_CODE < 0x020600
480 #define DEV_SIMPLE_TAGS(device) device->tagged_queue
482 * Hack around that qla1280_remove_one is called from
483 * qla1280_release in 2.4
488 #define DEV_SIMPLE_TAGS(device) device->simple_tags
490 #if defined(__ia64__) && !defined(ia64_platform_is)
491 #define ia64_platform_is(foo) (!strcmp(x, platform_name))
495 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
496 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
497 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
498 #define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
499 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
502 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
503 static void qla1280_remove_one(struct pci_dev *);
506 * QLogic Driver Support Function Prototypes.
508 static void qla1280_done(struct scsi_qla_host *);
509 #if LINUX_VERSION_CODE < 0x020545
510 static void qla1280_get_target_options(struct scsi_cmnd *, struct scsi_qla_host *);
512 static int qla1280_get_token(char *);
513 static int qla1280_setup(char *s) __init;
516 * QLogic ISP1280 Hardware Support Function Prototypes.
518 static int qla1280_load_firmware(struct scsi_qla_host *);
519 static int qla1280_init_rings(struct scsi_qla_host *);
520 static int qla1280_nvram_config(struct scsi_qla_host *);
521 static int qla1280_mailbox_command(struct scsi_qla_host *,
522 uint8_t, uint16_t *);
523 static int qla1280_bus_reset(struct scsi_qla_host *, int);
524 static int qla1280_device_reset(struct scsi_qla_host *, int, int);
525 static int qla1280_abort_device(struct scsi_qla_host *, int, int, int);
526 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
527 static int qla1280_abort_isp(struct scsi_qla_host *);
529 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
531 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
533 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
534 static void qla1280_poll(struct scsi_qla_host *);
535 static void qla1280_reset_adapter(struct scsi_qla_host *);
536 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
537 static void qla1280_isp_cmd(struct scsi_qla_host *);
538 static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
539 static void qla1280_rst_aen(struct scsi_qla_host *);
540 static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
542 static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
544 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
545 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
546 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
547 static request_t *qla1280_req_pkt(struct scsi_qla_host *);
548 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
550 static void qla1280_get_target_parameters(struct scsi_qla_host *,
551 struct scsi_device *);
552 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
555 static struct qla_driver_setup driver_setup;
558 * convert scsi data direction to request_t control flags
560 static inline uint16_t
561 qla1280_data_direction(struct scsi_cmnd *cmnd)
563 switch(cmnd->sc_data_direction) {
564 case DMA_FROM_DEVICE:
568 case DMA_BIDIRECTIONAL:
569 return BIT_5 | BIT_6;
571 * We could BUG() on default here if one of the four cases aren't
572 * met, but then again if we receive something like that from the
573 * SCSI layer we have more serious problems. This shuts up GCC.
582 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
583 static void __qla1280_dump_buffer(char *, int);
588 * insmod needs to find the variable and make it point to something
591 static char *qla1280;
593 /* insmod qla1280 options=verbose" */
594 module_param(qla1280, charp, 0);
596 __setup("qla1280=", qla1280_setup);
601 * We use the scsi_pointer structure that's included with each scsi_command
602 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
603 * bigger than a scsi_pointer.
606 #define CMD_SP(Cmnd) &Cmnd->SCp
607 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
608 #define CMD_CDBP(Cmnd) Cmnd->cmnd
609 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
610 #define CMD_SNSLEN(Cmnd) sizeof(Cmnd->sense_buffer)
611 #define CMD_RESULT(Cmnd) Cmnd->result
612 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
613 #if LINUX_VERSION_CODE < 0x020545
614 #define CMD_REQUEST(Cmnd) Cmnd->request.cmd
616 #define CMD_REQUEST(Cmnd) Cmnd->request->cmd
619 #define CMD_HOST(Cmnd) Cmnd->device->host
620 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
621 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
622 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
625 /*****************************************/
626 /* ISP Boards supported by this driver */
627 /*****************************************/
630 unsigned char name[9]; /* Board ID String */
631 int numPorts; /* Number of SCSI ports */
632 unsigned short *fwcode; /* pointer to FW array */
633 unsigned short *fwlen; /* number of words in array */
634 unsigned short *fwstart; /* start address for F/W */
635 unsigned char *fwver; /* Ptr to F/W version array */
638 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
639 static struct pci_device_id qla1280_pci_tbl[] = {
640 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
641 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
642 #ifdef CONFIG_SCSI_QLOGIC_1280_1040
643 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
644 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
646 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
647 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
648 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
649 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
650 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
651 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
652 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
653 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
656 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
658 static struct qla_boards ql1280_board_tbl[] = {
659 /* Name , Number of ports, FW details */
660 {"QLA12160", 2, &fw12160i_code01[0], &fw12160i_length01,
661 &fw12160i_addr01, &fw12160i_version_str[0]},
662 {"QLA1040", 1, &risc_code01[0], &risc_code_length01,
663 &risc_code_addr01, &firmware_version[0]},
664 {"QLA1080", 1, &fw1280ei_code01[0], &fw1280ei_length01,
665 &fw1280ei_addr01, &fw1280ei_version_str[0]},
666 {"QLA1240", 2, &fw1280ei_code01[0], &fw1280ei_length01,
667 &fw1280ei_addr01, &fw1280ei_version_str[0]},
668 {"QLA1280", 2, &fw1280ei_code01[0], &fw1280ei_length01,
669 &fw1280ei_addr01, &fw1280ei_version_str[0]},
670 {"QLA10160", 1, &fw12160i_code01[0], &fw12160i_length01,
671 &fw12160i_addr01, &fw12160i_version_str[0]},
675 static int qla1280_verbose = 1;
678 static int ql_debug_level = 1;
679 #define dprintk(level, format, a...) \
680 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
681 #define qla1280_dump_buffer(level, buf, size) \
682 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
683 #define qla1280_print_scsi_cmd(level, cmd) \
684 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
686 #define ql_debug_level 0
687 #define dprintk(level, format, a...) do{}while(0)
688 #define qla1280_dump_buffer(a, b, c) do{}while(0)
689 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
692 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
693 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
694 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
695 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
698 static int qla1280_read_nvram(struct scsi_qla_host *ha)
705 ENTER("qla1280_read_nvram");
707 if (driver_setup.no_nvram)
710 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
712 wptr = (uint16_t *)&ha->nvram;
715 for (cnt = 0; cnt < 3; cnt++) {
716 *wptr = qla1280_get_nvram_word(ha, cnt);
717 chksum += *wptr & 0xff;
718 chksum += (*wptr >> 8) & 0xff;
722 if (nv->id0 != 'I' || nv->id1 != 'S' ||
723 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
724 dprintk(2, "Invalid nvram ID or version!\n");
727 for (; cnt < sizeof(struct nvram); cnt++) {
728 *wptr = qla1280_get_nvram_word(ha, cnt);
729 chksum += *wptr & 0xff;
730 chksum += (*wptr >> 8) & 0xff;
735 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
736 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
741 if (!driver_setup.no_nvram)
742 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
743 "validate NVRAM checksum, using default "
744 "settings\n", ha->host_no);
749 /* The firmware interface is, um, interesting, in that the
750 * actual firmware image on the chip is little endian, thus,
751 * the process of taking that image to the CPU would end up
752 * little endian. However, the firmare interface requires it
753 * to be read a word (two bytes) at a time.
755 * The net result of this would be that the word (and
756 * doubleword) quantites in the firmware would be correct, but
757 * the bytes would be pairwise reversed. Since most of the
758 * firmware quantites are, in fact, bytes, we do an extra
759 * le16_to_cpu() in the firmware read routine.
761 * The upshot of all this is that the bytes in the firmware
762 * are in the correct places, but the 16 and 32 bit quantites
763 * are still in little endian format. We fix that up below by
764 * doing extra reverses on them */
765 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
766 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
767 for(i = 0; i < MAX_BUSES; i++) {
768 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
769 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
771 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
772 LEAVE("qla1280_read_nvram");
777 /**************************************************************************
779 * Return a string describing the driver.
780 **************************************************************************/
782 qla1280_info(struct Scsi_Host *host)
784 static char qla1280_scsi_name_buffer[125];
786 struct scsi_qla_host *ha;
787 struct qla_boards *bdp;
789 bp = &qla1280_scsi_name_buffer[0];
790 ha = (struct scsi_qla_host *)host->hostdata;
791 bdp = &ql1280_board_tbl[ha->devnum];
792 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
795 "QLogic %s PCI to SCSI Host Adapter\n"
796 " Firmware version: %2d.%02d.%02d, Driver version %s",
797 &bdp->name[0], bdp->fwver[0], bdp->fwver[1], bdp->fwver[2],
802 /**************************************************************************
803 * qla1200_queuecommand
804 * Queue a command to the controller.
807 * The mid-level driver tries to ensures that queuecommand never gets invoked
808 * concurrently with itself or the interrupt handler (although the
809 * interrupt handler may call this routine as part of request-completion
810 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
811 * context which is a big NO! NO!.
812 **************************************************************************/
814 qla1280_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
816 struct Scsi_Host *host = cmd->device->host;
817 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
818 struct srb *sp = (struct srb *)&cmd->SCp;
825 qla1280_print_scsi_cmd(5, cmd);
829 * Using 64 bit commands if the PCI bridge doesn't support it is a
830 * bit wasteful, however this should really only happen if one's
831 * PCI controller is completely broken, like the BCM1250. For
832 * sane hardware this is not an issue.
834 status = qla1280_64bit_start_scsi(ha, sp);
836 status = qla1280_32bit_start_scsi(ha, sp);
850 /* timer action for error action processor */
851 static void qla1280_error_wait_timeout(unsigned long __data)
853 struct scsi_cmnd *cmd = (struct scsi_cmnd *)__data;
854 struct srb *sp = (struct srb *)CMD_SP(cmd);
859 static void qla1280_mailbox_timeout(unsigned long __data)
861 struct scsi_qla_host *ha = (struct scsi_qla_host *)__data;
862 struct device_reg __iomem *reg;
865 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
866 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
867 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
868 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
869 complete(ha->mailbox_wait);
872 /**************************************************************************
873 * qla1200_error_action
874 * The function will attempt to perform a specified error action and
875 * wait for the results (or time out).
878 * cmd = Linux SCSI command packet of the command that cause the
880 * action = error action to take (see action_t)
886 * Resetting the bus always succeeds - is has to, otherwise the
887 * kernel will panic! Try a surgical technique - sending a BUS
888 * DEVICE RESET message - on the offending target before pulling
889 * the SCSI bus reset line.
890 **************************************************************************/
892 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
894 struct scsi_qla_host *ha;
895 int bus, target, lun;
898 unsigned char *handle;
900 DECLARE_COMPLETION(wait);
901 struct timer_list timer;
903 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
905 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
906 RD_REG_WORD(&ha->iobase->istatus));
908 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
909 RD_REG_WORD(&ha->iobase->host_cmd),
910 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
912 ENTER("qla1280_error_action");
914 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
915 "Handle=0x%p, action=0x%x\n",
916 ha->host_no, cmd, CMD_HANDLE(cmd), action);
919 printk(KERN_WARNING "(scsi?:?:?:?) Reset called with NULL "
920 "si_Cmnd pointer, failing.\n");
921 LEAVE("qla1280_error_action");
925 ha = (struct scsi_qla_host *)cmd->device->host->hostdata;
926 sp = (struct srb *)CMD_SP(cmd);
927 handle = CMD_HANDLE(cmd);
929 /* Check for pending interrupts. */
930 data = qla1280_debounce_register(&ha->iobase->istatus);
932 * The io_request_lock is held when the reset handler is called, hence
933 * the interrupt handler cannot be running in parallel as it also
934 * grabs the lock. /Jes
937 qla1280_isr(ha, &ha->done_q);
940 * Determine the suggested action that the mid-level driver wants
943 if (handle == (unsigned char *)INVALID_HANDLE || handle == NULL) {
944 if(action == ABORT_COMMAND) {
945 /* we never got this command */
946 printk(KERN_INFO "qla1280: Aborting a NULL handle\n");
947 return SUCCESS; /* no action - we don't have command */
953 bus = SCSI_BUS_32(cmd);
954 target = SCSI_TCN_32(cmd);
955 lun = SCSI_LUN_32(cmd);
957 /* Overloading result. Here it means the success or fail of the
958 * *issue* of the action. When we return from the routine, it must
959 * mean the actual success or fail of the action */
966 if ((sp->flags & SRB_ABORT_PENDING)) {
968 "scsi(): Command has a pending abort "
969 "message - ABORT_PENDING.\n");
970 /* This should technically be impossible since we
971 * now wait for abort completion */
975 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
976 if (sp == ha->outstanding_cmds[i]) {
977 dprintk(1, "qla1280: RISC aborting command\n");
978 if (qla1280_abort_command(ha, sp, i) == 0)
982 * Since we don't know what might
983 * have happend to the command, it
984 * is unsafe to remove it from the
985 * device's queue at this point.
986 * Wait and let the escalation
987 * process take care of it.
990 "scsi(%li:%i:%i:%i): Unable"
991 " to abort command!\n",
992 ha->host_no, bus, target, lun);
1001 "scsi(%ld:%d:%d:%d): Queueing abort device "
1002 "command.\n", ha->host_no, bus, target, lun);
1003 if (qla1280_abort_device(ha, bus, target, lun) == 0)
1008 if (qla1280_verbose)
1010 "scsi(%ld:%d:%d:%d): Queueing device reset "
1011 "command.\n", ha->host_no, bus, target, lun);
1012 if (qla1280_device_reset(ha, bus, target) == 0)
1017 if (qla1280_verbose)
1018 printk(KERN_INFO "qla1280(%ld:%d): Issuing BUS "
1019 "DEVICE RESET\n", ha->host_no, bus);
1020 if (qla1280_bus_reset(ha, bus == 0))
1027 if (qla1280_verbose) {
1029 "scsi(%ld): Issued ADAPTER RESET\n",
1031 printk(KERN_INFO "scsi(%ld): I/O processing will "
1032 "continue automatically\n", ha->host_no);
1034 ha->flags.reset_active = 1;
1036 * We restarted all of the commands automatically, so the
1037 * mid-level code can expect completions momentitarily.
1039 if (qla1280_abort_isp(ha) == 0)
1042 ha->flags.reset_active = 0;
1045 if (!list_empty(&ha->done_q))
1048 /* If we didn't manage to issue the action, or we have no
1049 * command to wait for, exit here */
1050 if (result == FAILED || handle == NULL ||
1051 handle == (unsigned char *)INVALID_HANDLE) {
1053 * Clear completion queue to avoid qla1280_done() trying
1054 * to complete the command at a later stage after we
1055 * have exited the current context
1061 /* set up a timer just in case we're really jammed */
1063 timer.expires = jiffies + 4*HZ;
1064 timer.data = (unsigned long)cmd;
1065 timer.function = qla1280_error_wait_timeout;
1068 /* wait for the action to complete (or the timer to expire) */
1069 spin_unlock_irq(HOST_LOCK);
1070 wait_for_completion(&wait);
1071 del_timer_sync(&timer);
1072 spin_lock_irq(HOST_LOCK);
1075 /* the only action we might get a fail for is abort */
1076 if (action == ABORT_COMMAND) {
1077 if(sp->flags & SRB_ABORTED)
1084 dprintk(1, "RESET returning %d\n", result);
1086 LEAVE("qla1280_error_action");
1090 /**************************************************************************
1092 * Abort the specified SCSI command(s).
1093 **************************************************************************/
1095 qla1280_eh_abort(struct scsi_cmnd * cmd)
1099 spin_lock_irq(cmd->device->host->host_lock);
1100 rc = qla1280_error_action(cmd, ABORT_COMMAND);
1101 spin_unlock_irq(cmd->device->host->host_lock);
1106 /**************************************************************************
1107 * qla1280_device_reset
1108 * Reset the specified SCSI device
1109 **************************************************************************/
1111 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1115 spin_lock_irq(cmd->device->host->host_lock);
1116 rc = qla1280_error_action(cmd, DEVICE_RESET);
1117 spin_unlock_irq(cmd->device->host->host_lock);
1122 /**************************************************************************
1124 * Reset the specified bus.
1125 **************************************************************************/
1127 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1131 spin_lock_irq(cmd->device->host->host_lock);
1132 rc = qla1280_error_action(cmd, BUS_RESET);
1133 spin_unlock_irq(cmd->device->host->host_lock);
1138 /**************************************************************************
1139 * qla1280_adapter_reset
1140 * Reset the specified adapter (both channels)
1141 **************************************************************************/
1143 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1147 spin_lock_irq(cmd->device->host->host_lock);
1148 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1149 spin_unlock_irq(cmd->device->host->host_lock);
1155 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1156 sector_t capacity, int geom[])
1158 int heads, sectors, cylinders;
1162 cylinders = (unsigned long)capacity / (heads * sectors);
1163 if (cylinders > 1024) {
1166 cylinders = (unsigned long)capacity / (heads * sectors);
1167 /* if (cylinders > 1023)
1168 cylinders = 1023; */
1173 geom[2] = cylinders;
1178 #if LINUX_VERSION_CODE < 0x020600
1180 qla1280_detect(Scsi_Host_Template *template)
1182 struct pci_device_id *id = &qla1280_pci_tbl[0];
1183 struct pci_dev *pdev = NULL;
1186 if (sizeof(struct srb) > sizeof(Scsi_Pointer)) {
1188 "qla1280: struct srb too big, aborting\n");
1192 if ((DMA_BIDIRECTIONAL != PCI_DMA_BIDIRECTIONAL) ||
1193 (DMA_TO_DEVICE != PCI_DMA_TODEVICE) ||
1194 (DMA_FROM_DEVICE != PCI_DMA_FROMDEVICE) ||
1195 (DMA_NONE != PCI_DMA_NONE)) {
1197 "qla1280: dma direction bits don't match\n");
1203 * If we are called as a module, the qla1280 pointer may not be null
1204 * and it would point to our bootup string, just like on the lilo
1205 * command line. IF not NULL, then process this config string with
1209 * To add options at boot time add a line to your lilo.conf file like:
1210 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
1211 * which will result in the first four devices on the first two
1212 * controllers being set to a tagged queue depth of 32.
1215 qla1280_setup(qla1280);
1218 /* First Initialize QLA12160 on PCI Bus 1 Dev 2 */
1219 while ((pdev = pci_find_device(id->vendor, id->device, pdev))) {
1220 if (pdev->bus->number == 1 && PCI_SLOT(pdev->devfn) == 2) {
1221 if (!qla1280_probe_one(pdev, id))
1227 /* Try and find each different type of adapter we support */
1228 for (id = &qla1280_pci_tbl[0]; id->device; id++) {
1229 while ((pdev = pci_find_device(id->vendor, id->device, pdev))) {
1231 * skip QLA12160 already initialized on
1232 * PCI Bus 1 Dev 2 since we already initialized
1235 if (id->device == PCI_DEVICE_ID_QLOGIC_ISP12160 &&
1236 pdev->bus->number == 1 &&
1237 PCI_SLOT(pdev->devfn) == 2)
1240 if (!qla1280_probe_one(pdev, id))
1249 * This looks a bit ugly as we could just pass down host to
1250 * qla1280_remove_one, but I want to keep qla1280_release purely a wrapper
1251 * around pci_driver::remove as used from 2.6 onwards.
1254 qla1280_release(struct Scsi_Host *host)
1256 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
1258 qla1280_remove_one(ha->pdev);
1263 qla1280_biosparam_old(Disk * disk, kdev_t dev, int geom[])
1265 return qla1280_biosparam(disk->device, NULL, disk->capacity, geom);
1269 /* disable risc and host interrupts */
1271 qla1280_disable_intrs(struct scsi_qla_host *ha)
1273 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1274 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1277 /* enable risc and host interrupts */
1279 qla1280_enable_intrs(struct scsi_qla_host *ha)
1281 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1282 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1285 /**************************************************************************
1286 * qla1280_intr_handler
1287 * Handles the H/W interrupt
1288 **************************************************************************/
1290 qla1280_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1292 struct scsi_qla_host *ha;
1293 struct device_reg __iomem *reg;
1297 ENTER_INTR ("qla1280_intr_handler");
1298 ha = (struct scsi_qla_host *)dev_id;
1300 spin_lock(HOST_LOCK);
1305 qla1280_disable_intrs(ha);
1307 data = qla1280_debounce_register(®->istatus);
1308 /* Check for pending interrupts. */
1309 if (data & RISC_INT) {
1310 qla1280_isr(ha, &ha->done_q);
1313 if (!list_empty(&ha->done_q))
1316 spin_unlock(HOST_LOCK);
1318 qla1280_enable_intrs(ha);
1320 LEAVE_INTR("qla1280_intr_handler");
1321 return IRQ_RETVAL(handled);
1326 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1329 uint16_t mb[MAILBOX_REGISTER_COUNT];
1335 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1337 /* Set Target Parameters. */
1338 mb[0] = MBC_SET_TARGET_PARAMETERS;
1339 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
1342 mb[2] = (nv->bus[bus].target[target].parameter.c << 8);
1344 if (IS_ISP1x160(ha)) {
1345 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1346 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8) |
1347 nv->bus[bus].target[target].sync_period;
1348 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1349 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1352 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8) |
1353 nv->bus[bus].target[target].sync_period;
1356 status = qla1280_mailbox_command(ha, mr, &mb[0]);
1359 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1360 "qla1280_set_target_parameters() failed\n",
1361 ha->host_no, bus, target);
1366 /**************************************************************************
1367 * qla1280_slave_configure
1370 * Determines the queue depth for a given device. There are two ways
1371 * a queue depth can be obtained for a tagged queueing device. One
1372 * way is the default queue depth which is determined by whether
1373 * If it is defined, then it is used
1374 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1375 * default queue depth (dependent on the number of hardware SCBs).
1376 **************************************************************************/
1378 qla1280_slave_configure(struct scsi_device *device)
1380 struct scsi_qla_host *ha;
1381 int default_depth = 3;
1382 int bus = device->channel;
1383 int target = device->id;
1386 unsigned long flags;
1388 ha = (struct scsi_qla_host *)device->host->hostdata;
1391 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1394 if (device->tagged_supported &&
1395 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1396 scsi_adjust_queue_depth(device, MSG_ORDERED_TAG,
1397 ha->bus_settings[bus].hiwat);
1399 scsi_adjust_queue_depth(device, 0, default_depth);
1402 #if LINUX_VERSION_CODE > 0x020500
1403 nv->bus[bus].target[target].parameter.f.enable_sync = device->sdtr;
1404 nv->bus[bus].target[target].parameter.f.enable_wide = device->wdtr;
1405 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1408 if (driver_setup.no_sync ||
1409 (driver_setup.sync_mask &&
1410 (~driver_setup.sync_mask & (1 << target))))
1411 nv->bus[bus].target[target].parameter.f.enable_sync = 0;
1412 if (driver_setup.no_wide ||
1413 (driver_setup.wide_mask &&
1414 (~driver_setup.wide_mask & (1 << target))))
1415 nv->bus[bus].target[target].parameter.f.enable_wide = 0;
1416 if (IS_ISP1x160(ha)) {
1417 if (driver_setup.no_ppr ||
1418 (driver_setup.ppr_mask &&
1419 (~driver_setup.ppr_mask & (1 << target))))
1420 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1423 spin_lock_irqsave(HOST_LOCK, flags);
1424 if (nv->bus[bus].target[target].parameter.f.enable_sync)
1425 status = qla1280_set_target_parameters(ha, bus, target);
1426 qla1280_get_target_parameters(ha, device);
1427 spin_unlock_irqrestore(HOST_LOCK, flags);
1431 #if LINUX_VERSION_CODE < 0x020545
1432 /**************************************************************************
1433 * qla1280_select_queue_depth
1435 * Sets the queue depth for each SCSI device hanging off the input
1436 * host adapter. We use a queue depth of 2 for devices that do not
1437 * support tagged queueing.
1438 **************************************************************************/
1440 qla1280_select_queue_depth(struct Scsi_Host *host, struct scsi_device *sdev_q)
1442 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
1443 struct scsi_device *sdev;
1445 ENTER("qla1280_select_queue_depth");
1446 for (sdev = sdev_q; sdev; sdev = sdev->next)
1447 if (sdev->host == host)
1448 qla1280_slave_configure(sdev);
1451 qla1280_check_for_dead_scsi_bus(ha, sdev_q->channel);
1452 LEAVE("qla1280_select_queue_depth");
1458 * Process completed commands.
1461 * ha = adapter block pointer.
1464 qla1280_done(struct scsi_qla_host *ha)
1467 struct list_head *done_q;
1468 int bus, target, lun;
1469 struct scsi_cmnd *cmd;
1471 ENTER("qla1280_done");
1473 done_q = &ha->done_q;
1475 while (!list_empty(done_q)) {
1476 sp = list_entry(done_q->next, struct srb, list);
1478 list_del(&sp->list);
1481 bus = SCSI_BUS_32(cmd);
1482 target = SCSI_TCN_32(cmd);
1483 lun = SCSI_LUN_32(cmd);
1485 switch ((CMD_RESULT(cmd) >> 16)) {
1487 /* Issue marker command. */
1488 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1491 sp->flags &= ~SRB_ABORT_PENDING;
1492 sp->flags |= SRB_ABORTED;
1493 if (sp->flags & SRB_TIMEOUT)
1494 CMD_RESULT(sp->cmd) = DID_TIME_OUT << 16;
1500 /* Release memory used for this I/O */
1502 pci_unmap_sg(ha->pdev, cmd->request_buffer,
1503 cmd->use_sg, cmd->sc_data_direction);
1504 } else if (cmd->request_bufflen) {
1505 pci_unmap_single(ha->pdev, sp->saved_dma_handle,
1506 cmd->request_bufflen,
1507 cmd->sc_data_direction);
1510 /* Call the mid-level driver interrupt handler */
1511 CMD_HANDLE(sp->cmd) = (unsigned char *)INVALID_HANDLE;
1514 #if LINUX_VERSION_CODE < 0x020500
1515 if (cmd->cmnd[0] == INQUIRY)
1516 qla1280_get_target_options(cmd, ha);
1518 (*(cmd)->scsi_done)(cmd);
1520 if(sp->wait != NULL)
1523 LEAVE("qla1280_done");
1527 * Translates a ISP error to a Linux SCSI error
1530 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1532 int host_status = DID_ERROR;
1533 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1534 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1535 uint16_t residual_length = le16_to_cpu(sts->residual_length);
1536 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1537 #if DEBUG_QLA1280_INTR
1538 static char *reason[] = {
1550 #endif /* DEBUG_QLA1280_INTR */
1552 ENTER("qla1280_return_status");
1554 #if DEBUG_QLA1280_INTR
1556 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1561 switch (comp_status) {
1563 host_status = DID_OK;
1567 if (!(state_flags & SF_GOT_BUS))
1568 host_status = DID_NO_CONNECT;
1569 else if (!(state_flags & SF_GOT_TARGET))
1570 host_status = DID_BAD_TARGET;
1571 else if (!(state_flags & SF_SENT_CDB))
1572 host_status = DID_ERROR;
1573 else if (!(state_flags & SF_TRANSFERRED_DATA))
1574 host_status = DID_ERROR;
1575 else if (!(state_flags & SF_GOT_STATUS))
1576 host_status = DID_ERROR;
1577 else if (!(state_flags & SF_GOT_SENSE))
1578 host_status = DID_ERROR;
1582 host_status = DID_RESET;
1586 host_status = DID_ABORT;
1590 host_status = DID_TIME_OUT;
1593 case CS_DATA_OVERRUN:
1594 dprintk(2, "Data overrun 0x%x\n", residual_length);
1595 dprintk(2, "qla1280_return_status: response packet data\n");
1596 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1597 host_status = DID_ERROR;
1600 case CS_DATA_UNDERRUN:
1601 if ((cp->request_bufflen - residual_length) <
1604 "scsi: Underflow detected - retrying "
1606 host_status = DID_ERROR;
1608 host_status = DID_OK;
1612 host_status = DID_ERROR;
1616 #if DEBUG_QLA1280_INTR
1617 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1618 reason[host_status], scsi_status);
1621 LEAVE("qla1280_return_status");
1623 return (scsi_status & 0xff) | (host_status << 16);
1626 /****************************************************************************/
1627 /* QLogic ISP1280 Hardware Support Functions. */
1628 /****************************************************************************/
1631 * qla1280_initialize_adapter
1635 * ha = adapter block pointer.
1640 static int __devinit
1641 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1643 struct device_reg __iomem *reg;
1646 #if LINUX_VERSION_CODE > 0x020500
1647 unsigned long flags;
1650 ENTER("qla1280_initialize_adapter");
1652 /* Clear adapter flags. */
1653 ha->flags.online = 0;
1654 ha->flags.disable_host_adapter = 0;
1655 ha->flags.reset_active = 0;
1656 ha->flags.abort_isp_active = 0;
1658 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1659 if (ia64_platform_is("sn2")) {
1660 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
1661 "dual channel lockup workaround\n", ha->host_no);
1662 ha->flags.use_pci_vchannel = 1;
1663 driver_setup.no_nvram = 1;
1667 /* TODO: implement support for the 1040 nvram format */
1669 driver_setup.no_nvram = 1;
1671 dprintk(1, "Configure PCI space for adapter...\n");
1675 /* Insure mailbox registers are free. */
1676 WRT_REG_WORD(®->semaphore, 0);
1677 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1678 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1679 RD_REG_WORD(®->host_cmd);
1681 if (qla1280_read_nvram(ha)) {
1682 dprintk(2, "qla1280_initialize_adapter: failed to read "
1686 #if LINUX_VERSION_CODE >= 0x020500
1688 * It's necessary to grab the spin here as qla1280_mailbox_command
1689 * needs to be able to drop the lock unconditionally to wait
1691 * In 2.4 ->detect is called with the io_request_lock held.
1693 spin_lock_irqsave(HOST_LOCK, flags);
1696 status = qla1280_load_firmware(ha);
1698 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1703 /* Setup adapter based on NVRAM parameters. */
1704 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1705 qla1280_nvram_config(ha);
1707 if (ha->flags.disable_host_adapter) {
1712 status = qla1280_init_rings(ha);
1716 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1717 for (bus = 0; bus < ha->ports; bus++) {
1718 if (!ha->bus_settings[bus].disable_scsi_reset &&
1719 qla1280_bus_reset(ha, bus) &&
1720 qla1280_bus_reset(ha, bus))
1721 ha->bus_settings[bus].scsi_bus_dead = 1;
1724 ha->flags.online = 1;
1726 #if LINUX_VERSION_CODE >= 0x020500
1727 spin_unlock_irqrestore(HOST_LOCK, flags);
1730 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1732 LEAVE("qla1280_initialize_adapter");
1738 * Test chip for proper operation.
1741 * ha = adapter block pointer.
1747 qla1280_chip_diag(struct scsi_qla_host *ha)
1749 uint16_t mb[MAILBOX_REGISTER_COUNT];
1750 struct device_reg __iomem *reg = ha->iobase;
1754 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®->id_l);
1756 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1758 /* Soft reset chip and wait for it to finish. */
1759 WRT_REG_WORD(®->ictrl, ISP_RESET);
1762 * We can't do a traditional PCI write flush here by reading
1763 * back the register. The card will not respond once the reset
1764 * is in action and we end up with a machine check exception
1765 * instead. Nothing to do but wait and hope for the best.
1766 * A portable pci_write_flush(pdev) call would be very useful here.
1769 data = qla1280_debounce_register(®->ictrl);
1771 * Yet another QLogic gem ;-(
1773 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1775 data = RD_REG_WORD(®->ictrl);
1781 /* Reset register cleared by chip reset. */
1782 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1784 WRT_REG_WORD(®->cfg_1, 0);
1786 /* Reset RISC and disable BIOS which
1787 allows RISC to execute out of RAM. */
1788 WRT_REG_WORD(®->host_cmd, HC_RESET_RISC |
1789 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1791 RD_REG_WORD(®->id_l); /* Flush PCI write */
1792 data = qla1280_debounce_register(®->mailbox0);
1795 * I *LOVE* this code!
1797 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1799 data = RD_REG_WORD(®->mailbox0);
1805 /* Check product ID of chip */
1806 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1808 if (RD_REG_WORD(®->mailbox1) != PROD_ID_1 ||
1809 (RD_REG_WORD(®->mailbox2) != PROD_ID_2 &&
1810 RD_REG_WORD(®->mailbox2) != PROD_ID_2a) ||
1811 RD_REG_WORD(®->mailbox3) != PROD_ID_3 ||
1812 RD_REG_WORD(®->mailbox4) != PROD_ID_4) {
1813 printk(KERN_INFO "qla1280: Wrong product ID = "
1814 "0x%x,0x%x,0x%x,0x%x\n",
1815 RD_REG_WORD(®->mailbox1),
1816 RD_REG_WORD(®->mailbox2),
1817 RD_REG_WORD(®->mailbox3),
1818 RD_REG_WORD(®->mailbox4));
1823 * Enable ints early!!!
1825 qla1280_enable_intrs(ha);
1827 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1828 /* Wrap Incoming Mailboxes Test. */
1829 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1838 status = qla1280_mailbox_command(ha, 0xff, mb);
1842 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1843 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1845 printk(KERN_INFO "qla1280: Failed mbox check\n");
1849 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1852 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1857 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1859 uint16_t risc_address, *risc_code_address, risc_code_size;
1860 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1863 /* Load RISC code. */
1864 risc_address = *ql1280_board_tbl[ha->devnum].fwstart;
1865 risc_code_address = ql1280_board_tbl[ha->devnum].fwcode;
1866 risc_code_size = *ql1280_board_tbl[ha->devnum].fwlen;
1868 for (i = 0; i < risc_code_size; i++) {
1869 mb[0] = MBC_WRITE_RAM_WORD;
1870 mb[1] = risc_address + i;
1871 mb[2] = risc_code_address[i];
1873 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1875 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1884 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1886 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1888 uint16_t risc_address, *risc_code_address, risc_code_size;
1889 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1890 int err = 0, num, i;
1895 tbuf = pci_alloc_consistent(ha->pdev, 8000, &p_tbuf);
1900 /* Load RISC code. */
1901 risc_address = *ql1280_board_tbl[ha->devnum].fwstart;
1902 risc_code_address = ql1280_board_tbl[ha->devnum].fwcode;
1903 risc_code_size = *ql1280_board_tbl[ha->devnum].fwlen;
1905 dprintk(1, "%s: DMA RISC code (%i) words\n",
1906 __FUNCTION__, risc_code_size);
1909 while (risc_code_size > 0) {
1910 int warn __attribute__((unused)) = 0;
1914 if (cnt > risc_code_size)
1915 cnt = risc_code_size;
1917 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1919 risc_code_address, cnt, num, risc_address);
1920 for(i = 0; i < cnt; i++)
1921 ((uint16_t *)ha->request_ring)[i] =
1922 cpu_to_le16(risc_code_address[i]);
1924 mb[0] = MBC_LOAD_RAM;
1925 mb[1] = risc_address;
1927 mb[3] = ha->request_dma & 0xffff;
1928 mb[2] = (ha->request_dma >> 16) & 0xffff;
1929 mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
1930 mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
1931 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1932 __FUNCTION__, mb[0],
1933 (void *)(long)ha->request_dma,
1934 mb[6], mb[7], mb[2], mb[3]);
1935 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1938 printk(KERN_ERR "scsi(%li): Failed to load partial "
1939 "segment of f\n", ha->host_no);
1944 mb[0] = MBC_DUMP_RAM;
1945 mb[1] = risc_address;
1947 mb[3] = p_tbuf & 0xffff;
1948 mb[2] = (p_tbuf >> 16) & 0xffff;
1949 mb[7] = pci_dma_hi32(p_tbuf) & 0xffff;
1950 mb[6] = pci_dma_hi32(p_tbuf) >> 16;
1952 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1956 "Failed to dump partial segment of f/w\n");
1959 sp = (uint8_t *)ha->request_ring;
1960 for (i = 0; i < (cnt << 1); i++) {
1961 if (tbuf[i] != sp[i] && warn++ < 10) {
1962 printk(KERN_ERR "%s: FW compare error @ "
1963 "byte(0x%x) loop#=%x\n",
1964 __FUNCTION__, i, num);
1965 printk(KERN_ERR "%s: FWbyte=%x "
1967 __FUNCTION__, sp[i], tbuf[i]);
1972 risc_address += cnt;
1973 risc_code_size = risc_code_size - cnt;
1974 risc_code_address = risc_code_address + cnt;
1980 pci_free_consistent(ha->pdev, 8000, tbuf, p_tbuf);
1986 qla1280_start_firmware(struct scsi_qla_host *ha)
1988 uint16_t mb[MAILBOX_REGISTER_COUNT];
1991 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1994 /* Verify checksum of loaded RISC code. */
1995 mb[0] = MBC_VERIFY_CHECKSUM;
1996 /* mb[1] = ql12_risc_code_addr01; */
1997 mb[1] = *ql1280_board_tbl[ha->devnum].fwstart;
1998 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2000 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
2004 /* Start firmware execution. */
2005 dprintk(1, "%s: start firmware running.\n", __FUNCTION__);
2006 mb[0] = MBC_EXECUTE_FIRMWARE;
2007 mb[1] = *ql1280_board_tbl[ha->devnum].fwstart;
2008 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2010 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
2018 qla1280_load_firmware(struct scsi_qla_host *ha)
2022 err = qla1280_chip_diag(ha);
2026 err = qla1280_load_firmware_pio(ha);
2028 err = qla1280_load_firmware_dma(ha);
2031 err = qla1280_start_firmware(ha);
2040 * ha = adapter block pointer.
2041 * ha->request_ring = request ring virtual address
2042 * ha->response_ring = response ring virtual address
2043 * ha->request_dma = request ring physical address
2044 * ha->response_dma = response ring physical address
2050 qla1280_init_rings(struct scsi_qla_host *ha)
2052 uint16_t mb[MAILBOX_REGISTER_COUNT];
2055 ENTER("qla1280_init_rings");
2057 /* Clear outstanding commands array. */
2058 memset(ha->outstanding_cmds, 0,
2059 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
2061 /* Initialize request queue. */
2062 ha->request_ring_ptr = ha->request_ring;
2063 ha->req_ring_index = 0;
2064 ha->req_q_cnt = REQUEST_ENTRY_CNT;
2065 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
2066 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
2067 mb[1] = REQUEST_ENTRY_CNT;
2068 mb[3] = ha->request_dma & 0xffff;
2069 mb[2] = (ha->request_dma >> 16) & 0xffff;
2071 mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
2072 mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
2073 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
2074 BIT_3 | BIT_2 | BIT_1 | BIT_0,
2076 /* Initialize response queue. */
2077 ha->response_ring_ptr = ha->response_ring;
2078 ha->rsp_ring_index = 0;
2079 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
2080 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
2081 mb[1] = RESPONSE_ENTRY_CNT;
2082 mb[3] = ha->response_dma & 0xffff;
2083 mb[2] = (ha->response_dma >> 16) & 0xffff;
2085 mb[7] = pci_dma_hi32(ha->response_dma) & 0xffff;
2086 mb[6] = pci_dma_hi32(ha->response_dma) >> 16;
2087 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
2088 BIT_3 | BIT_2 | BIT_1 | BIT_0,
2093 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
2095 LEAVE("qla1280_init_rings");
2100 qla1280_print_settings(struct nvram *nv)
2102 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
2103 nv->bus[0].config_1.initiator_id);
2104 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
2105 nv->bus[1].config_1.initiator_id);
2107 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
2108 nv->bus[0].bus_reset_delay);
2109 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
2110 nv->bus[1].bus_reset_delay);
2112 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
2113 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
2114 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
2115 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
2117 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
2118 nv->bus[0].config_2.async_data_setup_time);
2119 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
2120 nv->bus[1].config_2.async_data_setup_time);
2122 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
2123 nv->bus[0].config_2.req_ack_active_negation);
2124 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
2125 nv->bus[1].config_2.req_ack_active_negation);
2127 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
2128 nv->bus[0].config_2.data_line_active_negation);
2129 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
2130 nv->bus[1].config_2.data_line_active_negation);
2132 dprintk(1, "qla1280 : disable loading risc code=%d\n",
2133 nv->cntr_flags_1.disable_loading_risc_code);
2135 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
2136 nv->cntr_flags_1.enable_64bit_addressing);
2138 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
2139 nv->bus[0].selection_timeout);
2140 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
2141 nv->bus[1].selection_timeout);
2143 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
2144 nv->bus[0].max_queue_depth);
2145 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
2146 nv->bus[1].max_queue_depth);
2150 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
2152 struct nvram *nv = &ha->nvram;
2154 nv->bus[bus].target[target].parameter.f.renegotiate_on_error = 1;
2155 nv->bus[bus].target[target].parameter.f.auto_request_sense = 1;
2156 nv->bus[bus].target[target].parameter.f.tag_queuing = 1;
2157 nv->bus[bus].target[target].parameter.f.enable_sync = 1;
2158 #if 1 /* Some SCSI Processors do not seem to like this */
2159 nv->bus[bus].target[target].parameter.f.enable_wide = 1;
2161 nv->bus[bus].target[target].parameter.f.parity_checking = 1;
2162 nv->bus[bus].target[target].parameter.f.disconnect_allowed = 1;
2163 nv->bus[bus].target[target].execution_throttle =
2164 nv->bus[bus].max_queue_depth - 1;
2166 if (IS_ISP1x160(ha)) {
2167 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2168 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2169 nv->bus[bus].target[target].sync_period = 9;
2170 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2171 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2172 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2174 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2175 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2176 nv->bus[bus].target[target].sync_period = 10;
2181 qla1280_set_defaults(struct scsi_qla_host *ha)
2183 struct nvram *nv = &ha->nvram;
2186 dprintk(1, "Using defaults for NVRAM: \n");
2187 memset(nv, 0, sizeof(struct nvram));
2189 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2190 nv->firmware_feature.f.enable_fast_posting = 1;
2191 nv->firmware_feature.f.disable_synchronous_backoff = 1;
2192 nv->termination.scsi_bus_0_control = 3;
2193 nv->termination.scsi_bus_1_control = 3;
2194 nv->termination.auto_term_support = 1;
2197 * Set default FIFO magic - What appropriate values would be here
2198 * is unknown. This is what I have found testing with 12160s.
2200 * Now, I would love the magic decoder ring for this one, the
2201 * header file provided by QLogic seems to be bogus or incomplete
2204 nv->isp_config.burst_enable = 1;
2206 nv->isp_config.fifo_threshold |= 3;
2208 nv->isp_config.fifo_threshold |= 4;
2210 if (IS_ISP1x160(ha))
2211 nv->isp_parameter = 0x01; /* fast memory enable */
2213 for (bus = 0; bus < MAX_BUSES; bus++) {
2214 nv->bus[bus].config_1.initiator_id = 7;
2215 nv->bus[bus].config_2.req_ack_active_negation = 1;
2216 nv->bus[bus].config_2.data_line_active_negation = 1;
2217 nv->bus[bus].selection_timeout = 250;
2218 nv->bus[bus].max_queue_depth = 256;
2220 if (IS_ISP1040(ha)) {
2221 nv->bus[bus].bus_reset_delay = 3;
2222 nv->bus[bus].config_2.async_data_setup_time = 6;
2223 nv->bus[bus].retry_delay = 1;
2225 nv->bus[bus].bus_reset_delay = 5;
2226 nv->bus[bus].config_2.async_data_setup_time = 8;
2229 for (target = 0; target < MAX_TARGETS; target++)
2230 qla1280_set_target_defaults(ha, bus, target);
2235 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2237 struct nvram *nv = &ha->nvram;
2238 uint16_t mb[MAILBOX_REGISTER_COUNT];
2241 /* Set Target Parameters. */
2242 mb[0] = MBC_SET_TARGET_PARAMETERS;
2243 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
2247 * Do not enable wide, sync, and ppr for the initial
2248 * INQUIRY run. We enable this later if we determine
2249 * the target actually supports it.
2251 nv->bus[bus].target[target].parameter.f.
2252 auto_request_sense = 1;
2253 nv->bus[bus].target[target].parameter.f.
2254 stop_queue_on_check = 0;
2256 if (IS_ISP1x160(ha))
2257 nv->bus[bus].target[target].ppr_1x160.
2258 flags.enable_ppr = 0;
2261 * No sync, wide, etc. while probing
2263 mb[2] = (nv->bus[bus].target[target].parameter.c << 8) &
2264 ~(TP_SYNC /*| TP_WIDE | TP_PPR*/);
2266 if (IS_ISP1x160(ha))
2267 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2269 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2270 mb[3] |= nv->bus[bus].target[target].sync_period;
2272 status = qla1280_mailbox_command(ha, BIT_3 | BIT_2 | BIT_1 | BIT_0, &mb[0]);
2274 /* Save Tag queuing enable flag. */
2275 mb[0] = BIT_0 << target;
2276 if (nv->bus[bus].target[target].parameter.f.tag_queuing)
2277 ha->bus_settings[bus].qtag_enables |= mb[0];
2279 /* Save Device enable flag. */
2280 if (IS_ISP1x160(ha)) {
2281 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2282 ha->bus_settings[bus].device_enables |= mb[0];
2283 ha->bus_settings[bus].lun_disables |= 0;
2285 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2286 ha->bus_settings[bus].device_enables |= mb[0];
2287 /* Save LUN disable flag. */
2288 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2289 ha->bus_settings[bus].lun_disables |= mb[0];
2292 /* Set Device Queue Parameters. */
2293 for (lun = 0; lun < MAX_LUNS; lun++) {
2294 mb[0] = MBC_SET_DEVICE_QUEUE;
2295 mb[1] = (uint16_t)(bus ? target | BIT_7 : target);
2296 mb[1] = mb[1] << 8 | lun;
2297 mb[2] = nv->bus[bus].max_queue_depth;
2298 mb[3] = nv->bus[bus].target[target].execution_throttle;
2299 status |= qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2306 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2308 struct nvram *nv = &ha->nvram;
2309 uint16_t mb[MAILBOX_REGISTER_COUNT];
2312 /* SCSI Reset Disable. */
2313 ha->bus_settings[bus].disable_scsi_reset =
2314 nv->bus[bus].config_1.scsi_reset_disable;
2317 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2318 mb[0] = MBC_SET_INITIATOR_ID;
2319 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2320 ha->bus_settings[bus].id;
2321 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2324 ha->bus_settings[bus].bus_reset_delay =
2325 nv->bus[bus].bus_reset_delay;
2327 /* Command queue depth per device. */
2328 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2330 /* Set target parameters. */
2331 for (target = 0; target < MAX_TARGETS; target++)
2332 status |= qla1280_config_target(ha, bus, target);
2338 qla1280_nvram_config(struct scsi_qla_host *ha)
2340 struct device_reg __iomem *reg = ha->iobase;
2341 struct nvram *nv = &ha->nvram;
2342 int bus, target, status = 0;
2343 uint16_t mb[MAILBOX_REGISTER_COUNT];
2346 ENTER("qla1280_nvram_config");
2348 if (ha->nvram_valid) {
2349 /* Always force AUTO sense for LINUX SCSI */
2350 for (bus = 0; bus < MAX_BUSES; bus++)
2351 for (target = 0; target < MAX_TARGETS; target++) {
2352 nv->bus[bus].target[target].parameter.f.
2353 auto_request_sense = 1;
2356 qla1280_set_defaults(ha);
2359 qla1280_print_settings(nv);
2361 /* Disable RISC load of firmware. */
2362 ha->flags.disable_risc_code_load =
2363 nv->cntr_flags_1.disable_loading_risc_code;
2365 if (IS_ISP1040(ha)) {
2366 uint16_t hwrev, cfg1, cdma_conf, ddma_conf;
2368 hwrev = RD_REG_WORD(®->cfg_0) & ISP_CFG0_HWMSK;
2370 cfg1 = RD_REG_WORD(®->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2371 cdma_conf = RD_REG_WORD(®->cdma_cfg);
2372 ddma_conf = RD_REG_WORD(®->ddma_cfg);
2374 /* Busted fifo, says mjacob. */
2375 if (hwrev != ISP_CFG0_1040A)
2376 cfg1 |= nv->isp_config.fifo_threshold << 4;
2378 cfg1 |= nv->isp_config.burst_enable << 2;
2379 WRT_REG_WORD(®->cfg_1, cfg1);
2381 WRT_REG_WORD(®->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2382 WRT_REG_WORD(®->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2384 uint16_t cfg1, term;
2386 /* Set ISP hardware DMA burst */
2387 cfg1 = nv->isp_config.fifo_threshold << 4;
2388 cfg1 |= nv->isp_config.burst_enable << 2;
2389 /* Enable DMA arbitration on dual channel controllers */
2392 WRT_REG_WORD(®->cfg_1, cfg1);
2394 /* Set SCSI termination. */
2395 WRT_REG_WORD(®->gpio_enable,
2396 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2397 term = nv->termination.scsi_bus_1_control;
2398 term |= nv->termination.scsi_bus_0_control << 2;
2399 term |= nv->termination.auto_term_support << 7;
2400 RD_REG_WORD(®->id_l); /* Flush PCI write */
2401 WRT_REG_WORD(®->gpio_data, term);
2403 RD_REG_WORD(®->id_l); /* Flush PCI write */
2405 /* ISP parameter word. */
2406 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2407 mb[1] = nv->isp_parameter;
2408 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2410 if (IS_ISP1x40(ha)) {
2411 /* clock rate - for qla1240 and older, only */
2412 mb[0] = MBC_SET_CLOCK_RATE;
2414 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2417 /* Firmware feature word. */
2418 mb[0] = MBC_SET_FIRMWARE_FEATURES;
2419 mask = BIT_5 | BIT_1 | BIT_0;
2420 mb[1] = le16_to_cpu(nv->firmware_feature.w) & (mask);
2421 #if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2422 if (ia64_platform_is("sn2")) {
2423 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
2424 "workaround\n", ha->host_no);
2428 status |= qla1280_mailbox_command(ha, mask, &mb[0]);
2430 /* Retry count and delay. */
2431 mb[0] = MBC_SET_RETRY_COUNT;
2432 mb[1] = nv->bus[0].retry_count;
2433 mb[2] = nv->bus[0].retry_delay;
2434 mb[6] = nv->bus[1].retry_count;
2435 mb[7] = nv->bus[1].retry_delay;
2436 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2437 BIT_1 | BIT_0, &mb[0]);
2439 /* ASYNC data setup time. */
2440 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2441 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2442 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2443 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2445 /* Active negation states. */
2446 mb[0] = MBC_SET_ACTIVE_NEGATION;
2448 if (nv->bus[0].config_2.req_ack_active_negation)
2450 if (nv->bus[0].config_2.data_line_active_negation)
2453 if (nv->bus[1].config_2.req_ack_active_negation)
2455 if (nv->bus[1].config_2.data_line_active_negation)
2457 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2459 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2460 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2461 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2464 mb[0] = MBC_SET_PCI_CONTROL;
2465 mb[1] = 2; /* Data DMA Channel Burst Enable */
2466 mb[2] = 2; /* Command DMA Channel Burst Enable */
2467 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2469 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2471 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2473 /* Selection timeout. */
2474 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2475 mb[1] = nv->bus[0].selection_timeout;
2476 mb[2] = nv->bus[1].selection_timeout;
2477 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2479 for (bus = 0; bus < ha->ports; bus++)
2480 status |= qla1280_config_bus(ha, bus);
2483 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2485 LEAVE("qla1280_nvram_config");
2490 * Get NVRAM data word
2491 * Calculates word position in NVRAM and calls request routine to
2492 * get the word from NVRAM.
2495 * ha = adapter block pointer.
2496 * address = NVRAM word address.
2502 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2507 nv_cmd = address << 16;
2508 nv_cmd |= NV_READ_OP;
2510 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2512 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2520 * Sends read command to NVRAM and gets data from NVRAM.
2523 * ha = adapter block pointer.
2524 * nv_cmd = Bit 26 = start bit
2525 * Bit 25, 24 = opcode
2526 * Bit 23-16 = address
2527 * Bit 15-0 = write data
2533 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2535 struct device_reg __iomem *reg = ha->iobase;
2540 /* Send command to NVRAM. */
2543 for (cnt = 0; cnt < 11; cnt++) {
2544 if (nv_cmd & BIT_31)
2545 qla1280_nv_write(ha, NV_DATA_OUT);
2547 qla1280_nv_write(ha, 0);
2551 /* Read data from NVRAM. */
2553 for (cnt = 0; cnt < 16; cnt++) {
2554 WRT_REG_WORD(®->nvram, (NV_SELECT | NV_CLOCK));
2555 RD_REG_WORD(®->id_l); /* Flush PCI write */
2558 reg_data = RD_REG_WORD(®->nvram);
2559 if (reg_data & NV_DATA_IN)
2561 WRT_REG_WORD(®->nvram, NV_SELECT);
2562 RD_REG_WORD(®->id_l); /* Flush PCI write */
2566 /* Deselect chip. */
2568 WRT_REG_WORD(®->nvram, NV_DESELECT);
2569 RD_REG_WORD(®->id_l); /* Flush PCI write */
2576 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2578 struct device_reg __iomem *reg = ha->iobase;
2580 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2581 RD_REG_WORD(®->id_l); /* Flush PCI write */
2583 WRT_REG_WORD(®->nvram, data | NV_SELECT | NV_CLOCK);
2584 RD_REG_WORD(®->id_l); /* Flush PCI write */
2586 WRT_REG_WORD(®->nvram, data | NV_SELECT);
2587 RD_REG_WORD(®->id_l); /* Flush PCI write */
2593 * Issue mailbox command and waits for completion.
2596 * ha = adapter block pointer.
2597 * mr = mailbox registers to load.
2598 * mb = data pointer for mailbox registers.
2601 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2607 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2609 struct device_reg __iomem *reg = ha->iobase;
2615 uint16_t *optr, *iptr;
2616 uint16_t __iomem *mptr;
2618 DECLARE_COMPLETION(wait);
2619 struct timer_list timer;
2621 ENTER("qla1280_mailbox_command");
2623 if (ha->mailbox_wait) {
2624 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2626 ha->mailbox_wait = &wait;
2629 * We really should start out by verifying that the mailbox is
2630 * available before starting sending the command data
2632 /* Load mailbox registers. */
2633 mptr = (uint16_t __iomem *) ®->mailbox0;
2635 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2637 WRT_REG_WORD(mptr, (*iptr));
2645 /* Issue set host interrupt command. */
2647 /* set up a timer just in case we're really jammed */
2649 timer.expires = jiffies + 20*HZ;
2650 timer.data = (unsigned long)ha;
2651 timer.function = qla1280_mailbox_timeout;
2654 spin_unlock_irq(HOST_LOCK);
2655 WRT_REG_WORD(®->host_cmd, HC_SET_HOST_INT);
2656 data = qla1280_debounce_register(®->istatus);
2658 wait_for_completion(&wait);
2659 del_timer_sync(&timer);
2661 spin_lock_irq(HOST_LOCK);
2663 ha->mailbox_wait = NULL;
2665 /* Check for mailbox command timeout. */
2666 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2667 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2668 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2670 mb[0], ha->mailbox_out[0], RD_REG_WORD(®->istatus));
2671 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2672 RD_REG_WORD(®->mailbox0), RD_REG_WORD(®->mailbox1),
2673 RD_REG_WORD(®->mailbox2), RD_REG_WORD(®->mailbox3));
2674 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2675 RD_REG_WORD(®->mailbox4), RD_REG_WORD(®->mailbox5),
2676 RD_REG_WORD(®->mailbox6), RD_REG_WORD(®->mailbox7));
2680 /* Load return mailbox registers. */
2682 iptr = (uint16_t *) &ha->mailbox_out[0];
2683 mr = MAILBOX_REGISTER_COUNT;
2684 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2687 /* Go check for any response interrupts pending. */
2688 qla1280_isr(ha, &done_q);
2691 if (ha->flags.reset_marker)
2692 qla1280_rst_aen(ha);
2695 if (!list_empty(&done_q))
2696 qla1280_done(ha, &done_q);
2700 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2701 "0x%x ****\n", mb[0]);
2703 LEAVE("qla1280_mailbox_command");
2709 * Polls ISP for interrupts.
2712 * ha = adapter block pointer.
2715 qla1280_poll(struct scsi_qla_host *ha)
2717 struct device_reg __iomem *reg = ha->iobase;
2721 /* ENTER("qla1280_poll"); */
2723 /* Check for pending interrupts. */
2724 data = RD_REG_WORD(®->istatus);
2725 if (data & RISC_INT)
2726 qla1280_isr(ha, &done_q);
2728 if (!ha->mailbox_wait) {
2729 if (ha->flags.reset_marker)
2730 qla1280_rst_aen(ha);
2733 if (!list_empty(&done_q))
2736 /* LEAVE("qla1280_poll"); */
2741 * Issue SCSI bus reset.
2744 * ha = adapter block pointer.
2745 * bus = SCSI bus number.
2751 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2753 uint16_t mb[MAILBOX_REGISTER_COUNT];
2754 uint16_t reset_delay;
2757 dprintk(3, "qla1280_bus_reset: entered\n");
2759 if (qla1280_verbose)
2760 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2763 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2764 mb[0] = MBC_BUS_RESET;
2765 mb[1] = reset_delay;
2766 mb[2] = (uint16_t) bus;
2767 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2770 if (ha->bus_settings[bus].failed_reset_count > 2)
2771 ha->bus_settings[bus].scsi_bus_dead = 1;
2772 ha->bus_settings[bus].failed_reset_count++;
2774 spin_unlock_irq(HOST_LOCK);
2775 ssleep(reset_delay);
2776 spin_lock_irq(HOST_LOCK);
2778 ha->bus_settings[bus].scsi_bus_dead = 0;
2779 ha->bus_settings[bus].failed_reset_count = 0;
2780 ha->bus_settings[bus].reset_marker = 0;
2781 /* Issue marker command. */
2782 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2786 * We should probably call qla1280_set_target_parameters()
2787 * here as well for all devices on the bus.
2791 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2793 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2799 * qla1280_device_reset
2800 * Issue bus device reset message to the target.
2803 * ha = adapter block pointer.
2804 * bus = SCSI BUS number.
2811 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2813 uint16_t mb[MAILBOX_REGISTER_COUNT];
2816 ENTER("qla1280_device_reset");
2818 mb[0] = MBC_ABORT_TARGET;
2819 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2821 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2823 /* Issue marker command. */
2824 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2827 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2829 LEAVE("qla1280_device_reset");
2834 * qla1280_abort_device
2835 * Issue an abort message to the device
2838 * ha = adapter block pointer.
2847 qla1280_abort_device(struct scsi_qla_host *ha, int bus, int target, int lun)
2849 uint16_t mb[MAILBOX_REGISTER_COUNT];
2852 ENTER("qla1280_abort_device");
2854 mb[0] = MBC_ABORT_DEVICE;
2855 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2856 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2858 /* Issue marker command. */
2859 qla1280_marker(ha, bus, target, lun, MK_SYNC_ID_LUN);
2862 dprintk(2, "qla1280_abort_device: **** FAILED ****\n");
2864 LEAVE("qla1280_abort_device");
2869 * qla1280_abort_command
2870 * Abort command aborts a specified IOCB.
2873 * ha = adapter block pointer.
2874 * sp = SB structure pointer.
2880 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2882 uint16_t mb[MAILBOX_REGISTER_COUNT];
2883 unsigned int bus, target, lun;
2886 ENTER("qla1280_abort_command");
2888 bus = SCSI_BUS_32(sp->cmd);
2889 target = SCSI_TCN_32(sp->cmd);
2890 lun = SCSI_LUN_32(sp->cmd);
2892 sp->flags |= SRB_ABORT_PENDING;
2894 mb[0] = MBC_ABORT_COMMAND;
2895 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2896 mb[2] = handle >> 16;
2897 mb[3] = handle & 0xffff;
2898 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2901 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2902 sp->flags &= ~SRB_ABORT_PENDING;
2906 LEAVE("qla1280_abort_command");
2911 * qla1280_reset_adapter
2915 * ha = adapter block pointer.
2918 qla1280_reset_adapter(struct scsi_qla_host *ha)
2920 struct device_reg __iomem *reg = ha->iobase;
2922 ENTER("qla1280_reset_adapter");
2924 /* Disable ISP chip */
2925 ha->flags.online = 0;
2926 WRT_REG_WORD(®->ictrl, ISP_RESET);
2927 WRT_REG_WORD(®->host_cmd,
2928 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2929 RD_REG_WORD(®->id_l); /* Flush PCI write */
2931 LEAVE("qla1280_reset_adapter");
2935 * Issue marker command.
2936 * Function issues marker IOCB.
2939 * ha = adapter block pointer.
2940 * bus = SCSI BUS number
2943 * type = marker modifier
2946 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2948 struct mrk_entry *pkt;
2950 ENTER("qla1280_marker");
2952 /* Get request packet. */
2953 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2954 pkt->entry_type = MARKER_TYPE;
2955 pkt->lun = (uint8_t) lun;
2956 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2957 pkt->modifier = type;
2958 pkt->entry_status = 0;
2960 /* Issue command to ISP */
2961 qla1280_isp_cmd(ha);
2964 LEAVE("qla1280_marker");
2969 * qla1280_64bit_start_scsi
2970 * The start SCSI is responsible for building request packets on
2971 * request ring and modifying ISP input pointer.
2974 * ha = adapter block pointer.
2975 * sp = SB structure pointer.
2978 * 0 = success, was able to issue command.
2980 #ifdef QLA_64BIT_PTR
2982 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2984 struct device_reg __iomem *reg = ha->iobase;
2985 struct scsi_cmnd *cmd = sp->cmd;
2986 cmd_a64_entry_t *pkt;
2987 struct scatterlist *sg = NULL;
2989 dma_addr_t dma_handle;
2996 ENTER("qla1280_64bit_start_scsi:");
2998 /* Calculate number of entries and segments required. */
3001 sg = (struct scatterlist *) cmd->request_buffer;
3002 seg_cnt = pci_map_sg(ha->pdev, sg, cmd->use_sg,
3003 cmd->sc_data_direction);
3006 req_cnt += (seg_cnt - 2) / 5;
3007 if ((seg_cnt - 2) % 5)
3010 } else if (cmd->request_bufflen) { /* If data transfer. */
3016 if ((req_cnt + 2) >= ha->req_q_cnt) {
3017 /* Calculate number of free request entries. */
3018 cnt = RD_REG_WORD(®->mailbox4);
3019 if (ha->req_ring_index < cnt)
3020 ha->req_q_cnt = cnt - ha->req_ring_index;
3023 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3026 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3027 ha->req_q_cnt, seg_cnt);
3029 /* If room for request in request ring. */
3030 if ((req_cnt + 2) >= ha->req_q_cnt) {
3032 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
3033 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
3038 /* Check for room in outstanding command list. */
3039 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3040 ha->outstanding_cmds[cnt] != 0; cnt++);
3042 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3044 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
3045 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
3049 ha->outstanding_cmds[cnt] = sp;
3050 ha->req_q_cnt -= req_cnt;
3051 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
3053 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
3054 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
3055 dprintk(2, " bus %i, target %i, lun %i\n",
3056 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3057 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
3060 * Build command packet.
3062 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
3064 pkt->entry_type = COMMAND_A64_TYPE;
3065 pkt->entry_count = (uint8_t) req_cnt;
3066 pkt->sys_define = (uint8_t) ha->req_ring_index;
3067 pkt->entry_status = 0;
3068 pkt->handle = cpu_to_le32(cnt);
3070 /* Zero out remaining portion of packet. */
3071 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3073 /* Set ISP command timeout. */
3074 pkt->timeout = cpu_to_le16(30);
3076 /* Set device target ID and LUN */
3077 pkt->lun = SCSI_LUN_32(cmd);
3078 pkt->target = SCSI_BUS_32(cmd) ?
3079 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3081 /* Enable simple tag queuing if device supports it. */
3082 if (DEV_SIMPLE_TAGS(cmd->device))
3083 pkt->control_flags |= cpu_to_le16(BIT_3);
3085 /* Load SCSI command packet. */
3086 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3087 memcpy(pkt->scsi_cdb, &(CMD_CDBP(cmd)), CMD_CDBLEN(cmd));
3088 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3090 /* Set transfer direction. */
3091 dir = qla1280_data_direction(cmd);
3092 pkt->control_flags |= cpu_to_le16(dir);
3094 /* Set total data segment count. */
3095 pkt->dseg_count = cpu_to_le16(seg_cnt);
3098 * Load data segments.
3100 if (seg_cnt) { /* If data transfer. */
3101 /* Setup packet address segment pointer. */
3102 dword_ptr = (u32 *)&pkt->dseg_0_address;
3104 if (cmd->use_sg) { /* If scatter gather */
3105 /* Load command entry data segments. */
3106 for (cnt = 0; cnt < 2 && seg_cnt; cnt++, seg_cnt--) {
3107 dma_handle = sg_dma_address(sg);
3108 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3109 if (ha->flags.use_pci_vchannel)
3110 sn_pci_set_vchan(ha->pdev,
3111 (unsigned long *)&dma_handle,
3115 cpu_to_le32(pci_dma_lo32(dma_handle));
3117 cpu_to_le32(pci_dma_hi32(dma_handle));
3118 *dword_ptr++ = cpu_to_le32(sg_dma_len(sg));
3120 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
3121 cpu_to_le32(pci_dma_hi32(dma_handle)),
3122 cpu_to_le32(pci_dma_lo32(dma_handle)),
3123 cpu_to_le32(sg_dma_len(sg)));
3125 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
3126 "command packet data - b %i, t %i, l %i \n",
3127 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3129 qla1280_dump_buffer(5, (char *)pkt,
3130 REQUEST_ENTRY_SIZE);
3133 * Build continuation packets.
3135 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
3136 "remains\n", seg_cnt);
3138 while (seg_cnt > 0) {
3139 /* Adjust ring index. */
3140 ha->req_ring_index++;
3141 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3142 ha->req_ring_index = 0;
3143 ha->request_ring_ptr =
3146 ha->request_ring_ptr++;
3148 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
3150 /* Zero out packet. */
3151 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3153 /* Load packet defaults. */
3154 ((struct cont_a64_entry *) pkt)->entry_type =
3156 ((struct cont_a64_entry *) pkt)->entry_count = 1;
3157 ((struct cont_a64_entry *) pkt)->sys_define =
3158 (uint8_t)ha->req_ring_index;
3159 /* Setup packet address segment pointer. */
3161 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
3163 /* Load continuation entry data segments. */
3164 for (cnt = 0; cnt < 5 && seg_cnt;
3166 dma_handle = sg_dma_address(sg);
3167 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3168 if (ha->flags.use_pci_vchannel)
3169 sn_pci_set_vchan(ha->pdev,
3170 (unsigned long *)&dma_handle,
3174 cpu_to_le32(pci_dma_lo32(dma_handle));
3176 cpu_to_le32(pci_dma_hi32(dma_handle));
3178 cpu_to_le32(sg_dma_len(sg));
3179 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
3180 cpu_to_le32(pci_dma_hi32(dma_handle)),
3181 cpu_to_le32(pci_dma_lo32(dma_handle)),
3182 cpu_to_le32(sg_dma_len(sg)));
3185 dprintk(5, "qla1280_64bit_start_scsi: "
3186 "continuation packet data - b %i, t "
3187 "%i, l %i \n", SCSI_BUS_32(cmd),
3188 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3189 qla1280_dump_buffer(5, (char *)pkt,
3190 REQUEST_ENTRY_SIZE);
3192 } else { /* No scatter gather data transfer */
3193 dma_handle = pci_map_single(ha->pdev,
3194 cmd->request_buffer,
3195 cmd->request_bufflen,
3196 cmd->sc_data_direction);
3198 sp->saved_dma_handle = dma_handle;
3199 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3200 if (ha->flags.use_pci_vchannel)
3201 sn_pci_set_vchan(ha->pdev,
3202 (unsigned long *)&dma_handle,
3205 *dword_ptr++ = cpu_to_le32(pci_dma_lo32(dma_handle));
3206 *dword_ptr++ = cpu_to_le32(pci_dma_hi32(dma_handle));
3207 *dword_ptr = cpu_to_le32(cmd->request_bufflen);
3209 dprintk(5, "qla1280_64bit_start_scsi: No scatter/"
3210 "gather command packet data - b %i, t %i, "
3211 "l %i \n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3213 qla1280_dump_buffer(5, (char *)pkt,
3214 REQUEST_ENTRY_SIZE);
3216 } else { /* No data transfer */
3217 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
3218 "packet data - b %i, t %i, l %i \n",
3219 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3220 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3222 /* Adjust ring index. */
3223 ha->req_ring_index++;
3224 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3225 ha->req_ring_index = 0;
3226 ha->request_ring_ptr = ha->request_ring;
3228 ha->request_ring_ptr++;
3230 /* Set chip new ring index. */
3232 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3233 sp->flags |= SRB_SENT;
3235 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3236 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3241 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3243 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3247 #else /* !QLA_64BIT_PTR */
3250 * qla1280_32bit_start_scsi
3251 * The start SCSI is responsible for building request packets on
3252 * request ring and modifying ISP input pointer.
3254 * The Qlogic firmware interface allows every queue slot to have a SCSI
3255 * command and up to 4 scatter/gather (SG) entries. If we need more
3256 * than 4 SG entries, then continuation entries are used that can
3257 * hold another 7 entries each. The start routine determines if there
3258 * is eought empty slots then build the combination of requests to
3259 * fulfill the OS request.
3262 * ha = adapter block pointer.
3263 * sp = SCSI Request Block structure pointer.
3266 * 0 = success, was able to issue command.
3269 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
3271 struct device_reg __iomem *reg = ha->iobase;
3272 struct scsi_cmnd *cmd = sp->cmd;
3273 struct cmd_entry *pkt;
3274 struct scatterlist *sg = NULL;
3275 uint32_t *dword_ptr;
3280 dma_addr_t dma_handle;
3283 ENTER("qla1280_32bit_start_scsi");
3285 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3288 /* Calculate number of entries and segments required. */
3292 * We must build an SG list in adapter format, as the kernel's
3293 * SG list cannot be used directly because of data field size
3294 * (__alpha__) differences and the kernel SG list uses virtual
3295 * addresses where we need physical addresses.
3297 sg = (struct scatterlist *) cmd->request_buffer;
3298 seg_cnt = pci_map_sg(ha->pdev, sg, cmd->use_sg,
3299 cmd->sc_data_direction);
3302 * if greater than four sg entries then we need to allocate
3303 * continuation entries
3306 req_cnt += (seg_cnt - 4) / 7;
3307 if ((seg_cnt - 4) % 7)
3310 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3311 cmd, seg_cnt, req_cnt);
3312 } else if (cmd->request_bufflen) { /* If data transfer. */
3313 dprintk(3, "No S/G transfer t=%x cmd=%p len=%x CDB=%x\n",
3314 SCSI_TCN_32(cmd), cmd, cmd->request_bufflen,
3318 /* dprintk(1, "No data transfer \n"); */
3322 if ((req_cnt + 2) >= ha->req_q_cnt) {
3323 /* Calculate number of free request entries. */
3324 cnt = RD_REG_WORD(®->mailbox4);
3325 if (ha->req_ring_index < cnt)
3326 ha->req_q_cnt = cnt - ha->req_ring_index;
3329 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3332 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3333 ha->req_q_cnt, seg_cnt);
3334 /* If room for request in request ring. */
3335 if ((req_cnt + 2) >= ha->req_q_cnt) {
3337 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3338 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3339 ha->req_q_cnt, req_cnt);
3343 /* Check for empty slot in outstanding command list. */
3344 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3345 (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3347 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3349 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3350 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3354 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3355 ha->outstanding_cmds[cnt] = sp;
3356 ha->req_q_cnt -= req_cnt;
3359 * Build command packet.
3361 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3363 pkt->entry_type = COMMAND_TYPE;
3364 pkt->entry_count = (uint8_t) req_cnt;
3365 pkt->sys_define = (uint8_t) ha->req_ring_index;
3366 pkt->entry_status = 0;
3367 pkt->handle = cpu_to_le32(cnt);
3369 /* Zero out remaining portion of packet. */
3370 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3372 /* Set ISP command timeout. */
3373 pkt->timeout = cpu_to_le16(30);
3375 /* Set device target ID and LUN */
3376 pkt->lun = SCSI_LUN_32(cmd);
3377 pkt->target = SCSI_BUS_32(cmd) ?
3378 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3380 /* Enable simple tag queuing if device supports it. */
3381 if (DEV_SIMPLE_TAGS(cmd->device))
3382 pkt->control_flags |= cpu_to_le16(BIT_3);
3384 /* Load SCSI command packet. */
3385 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3386 memcpy(pkt->scsi_cdb, &(CMD_CDBP(cmd)), CMD_CDBLEN(cmd));
3388 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3389 /* Set transfer direction. */
3390 dir = qla1280_data_direction(cmd);
3391 pkt->control_flags |= cpu_to_le16(dir);
3393 /* Set total data segment count. */
3394 pkt->dseg_count = cpu_to_le16(seg_cnt);
3397 * Load data segments.
3400 /* Setup packet address segment pointer. */
3401 dword_ptr = &pkt->dseg_0_address;
3403 if (cmd->use_sg) { /* If scatter gather */
3404 dprintk(3, "Building S/G data segments..\n");
3405 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3407 /* Load command entry data segments. */
3408 for (cnt = 0; cnt < 4 && seg_cnt; cnt++, seg_cnt--) {
3410 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg)));
3412 cpu_to_le32(sg_dma_len(sg));
3413 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3414 (pci_dma_lo32(sg_dma_address(sg))),
3419 * Build continuation packets.
3421 dprintk(3, "S/G Building Continuation"
3422 "...seg_cnt=0x%x remains\n", seg_cnt);
3423 while (seg_cnt > 0) {
3424 /* Adjust ring index. */
3425 ha->req_ring_index++;
3426 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3427 ha->req_ring_index = 0;
3428 ha->request_ring_ptr =
3431 ha->request_ring_ptr++;
3433 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3435 /* Zero out packet. */
3436 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3438 /* Load packet defaults. */
3439 ((struct cont_entry *) pkt)->
3440 entry_type = CONTINUE_TYPE;
3441 ((struct cont_entry *) pkt)->entry_count = 1;
3443 ((struct cont_entry *) pkt)->sys_define =
3444 (uint8_t) ha->req_ring_index;
3446 /* Setup packet address segment pointer. */
3448 &((struct cont_entry *) pkt)->dseg_0_address;
3450 /* Load continuation entry data segments. */
3451 for (cnt = 0; cnt < 7 && seg_cnt;
3454 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg)));
3456 cpu_to_le32(sg_dma_len(sg));
3458 "S/G Segment Cont. phys_addr=0x%x, "
3460 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg))),
3461 cpu_to_le32(sg_dma_len(sg)));
3464 dprintk(5, "qla1280_32bit_start_scsi: "
3465 "continuation packet data - "
3466 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3467 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3468 qla1280_dump_buffer(5, (char *)pkt,
3469 REQUEST_ENTRY_SIZE);
3471 } else { /* No S/G data transfer */
3472 dma_handle = pci_map_single(ha->pdev,
3473 cmd->request_buffer,
3474 cmd->request_bufflen,
3475 cmd->sc_data_direction);
3476 sp->saved_dma_handle = dma_handle;
3478 *dword_ptr++ = cpu_to_le32(pci_dma_lo32(dma_handle));
3479 *dword_ptr = cpu_to_le32(cmd->request_bufflen);
3481 } else { /* No data transfer at all */
3482 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3483 "packet data - \n");
3484 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3486 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3487 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3488 REQUEST_ENTRY_SIZE);
3490 /* Adjust ring index. */
3491 ha->req_ring_index++;
3492 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3493 ha->req_ring_index = 0;
3494 ha->request_ring_ptr = ha->request_ring;
3496 ha->request_ring_ptr++;
3498 /* Set chip new ring index. */
3499 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3500 "for pending command\n");
3501 sp->flags |= SRB_SENT;
3503 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3504 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3509 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3511 LEAVE("qla1280_32bit_start_scsi");
3519 * Function is responsible for locking ring and
3520 * getting a zeroed out request packet.
3523 * ha = adapter block pointer.
3526 * 0 = failed to get slot.
3529 qla1280_req_pkt(struct scsi_qla_host *ha)
3531 struct device_reg __iomem *reg = ha->iobase;
3532 request_t *pkt = NULL;
3536 ENTER("qla1280_req_pkt");
3539 * This can be called from interrupt context, damn it!!!
3541 /* Wait for 30 seconds for slot. */
3542 for (timer = 15000000; timer; timer--) {
3543 if (ha->req_q_cnt > 0) {
3544 /* Calculate number of free request entries. */
3545 cnt = RD_REG_WORD(®->mailbox4);
3546 if (ha->req_ring_index < cnt)
3547 ha->req_q_cnt = cnt - ha->req_ring_index;
3550 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3553 /* Found empty request ring slot? */
3554 if (ha->req_q_cnt > 0) {
3556 pkt = ha->request_ring_ptr;
3558 /* Zero out packet. */
3559 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3562 * How can this be right when we have a ring
3565 /* Set system defined field. */
3566 pkt->sys_define = (uint8_t) ha->req_ring_index;
3568 /* Set entry count. */
3569 pkt->entry_count = 1;
3576 /* Check for pending interrupts. */
3581 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3583 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3590 * Function is responsible for modifying ISP input pointer.
3591 * Releases ring lock.
3594 * ha = adapter block pointer.
3597 qla1280_isp_cmd(struct scsi_qla_host *ha)
3599 struct device_reg __iomem *reg = ha->iobase;
3601 ENTER("qla1280_isp_cmd");
3603 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3604 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3605 REQUEST_ENTRY_SIZE);
3607 /* Adjust ring index. */
3608 ha->req_ring_index++;
3609 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3610 ha->req_ring_index = 0;
3611 ha->request_ring_ptr = ha->request_ring;
3613 ha->request_ring_ptr++;
3616 * Update request index to mailbox4 (Request Queue In).
3617 * The mmiowb() ensures that this write is ordered with writes by other
3618 * CPUs. Without the mmiowb(), it is possible for the following:
3619 * CPUA posts write of index 5 to mailbox4
3620 * CPUA releases host lock
3621 * CPUB acquires host lock
3622 * CPUB posts write of index 6 to mailbox4
3623 * On PCI bus, order reverses and write of 6 posts, then index 5,
3624 * causing chip to issue full queue of stale commands
3625 * The mmiowb() prevents future writes from crossing the barrier.
3626 * See Documentation/DocBook/deviceiobook.tmpl for more information.
3628 WRT_REG_WORD(®->mailbox4, ha->req_ring_index);
3631 LEAVE("qla1280_isp_cmd");
3634 /****************************************************************************/
3635 /* Interrupt Service Routine. */
3636 /****************************************************************************/
3638 /****************************************************************************
3640 * Calls I/O done on command completion.
3643 * ha = adapter block pointer.
3644 * done_q = done queue.
3645 ****************************************************************************/
3647 qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3649 struct device_reg __iomem *reg = ha->iobase;
3650 struct response *pkt;
3651 struct srb *sp = NULL;
3652 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3657 ENTER("qla1280_isr");
3659 istatus = RD_REG_WORD(®->istatus);
3660 if (!(istatus & (RISC_INT | PCI_INT)))
3663 /* Save mailbox register 5 */
3664 mailbox[5] = RD_REG_WORD(®->mailbox5);
3666 /* Check for mailbox interrupt. */
3668 mailbox[0] = RD_REG_WORD_dmasync(®->semaphore);
3670 if (mailbox[0] & BIT_0) {
3671 /* Get mailbox data. */
3672 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3675 *wptr++ = RD_REG_WORD(®->mailbox0);
3676 *wptr++ = RD_REG_WORD(®->mailbox1);
3677 *wptr = RD_REG_WORD(®->mailbox2);
3678 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3680 *wptr++ = RD_REG_WORD(®->mailbox3);
3681 *wptr++ = RD_REG_WORD(®->mailbox4);
3683 *wptr++ = RD_REG_WORD(®->mailbox6);
3684 *wptr = RD_REG_WORD(®->mailbox7);
3687 /* Release mailbox registers. */
3689 WRT_REG_WORD(®->semaphore, 0);
3690 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3692 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3695 /* Handle asynchronous event */
3696 switch (mailbox[0]) {
3697 case MBA_SCSI_COMPLETION: /* Response completion */
3698 dprintk(5, "qla1280_isr: mailbox SCSI response "
3701 if (ha->flags.online) {
3702 /* Get outstanding command index. */
3703 index = mailbox[2] << 16 | mailbox[1];
3705 /* Validate handle. */
3706 if (index < MAX_OUTSTANDING_COMMANDS)
3707 sp = ha->outstanding_cmds[index];
3712 /* Free outstanding command slot. */
3713 ha->outstanding_cmds[index] = NULL;
3715 /* Save ISP completion status */
3716 CMD_RESULT(sp->cmd) = 0;
3718 /* Place block on done queue */
3719 list_add_tail(&sp->list, done_q);
3722 * If we get here we have a real problem!
3725 "qla1280: ISP invalid handle");
3730 case MBA_BUS_RESET: /* SCSI Bus Reset */
3731 ha->flags.reset_marker = 1;
3732 index = mailbox[6] & BIT_0;
3733 ha->bus_settings[index].reset_marker = 1;
3735 printk(KERN_DEBUG "qla1280_isr(): index %i "
3736 "asynchronous BUS_RESET\n", index);
3739 case MBA_SYSTEM_ERR: /* System Error */
3741 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3742 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3746 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3748 "qla1280: ISP Request Transfer Error\n");
3751 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3753 "qla1280: ISP Response Transfer Error\n");
3756 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3757 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3760 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3762 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3765 case MBA_DEVICE_RESET: /* Bus Device Reset */
3766 printk(KERN_INFO "qla1280_isr(): asynchronous "
3767 "BUS_DEVICE_RESET\n");
3769 ha->flags.reset_marker = 1;
3770 index = mailbox[6] & BIT_0;
3771 ha->bus_settings[index].reset_marker = 1;
3774 case MBA_BUS_MODE_CHANGE:
3776 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3780 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3781 if (mailbox[0] < MBA_ASYNC_EVENT) {
3783 memcpy((uint16_t *) ha->mailbox_out, wptr,
3784 MAILBOX_REGISTER_COUNT *
3787 if(ha->mailbox_wait != NULL)
3788 complete(ha->mailbox_wait);
3793 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
3797 * We will receive interrupts during mailbox testing prior to
3798 * the card being marked online, hence the double check.
3800 if (!(ha->flags.online && !ha->mailbox_wait)) {
3801 dprintk(2, "qla1280_isr: Response pointer Error\n");
3805 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3808 while (ha->rsp_ring_index != mailbox[5]) {
3809 pkt = ha->response_ring_ptr;
3811 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3812 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3813 dprintk(5,"qla1280_isr: response packet data\n");
3814 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3816 if (pkt->entry_type == STATUS_TYPE) {
3817 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3818 || pkt->comp_status || pkt->entry_status) {
3819 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3820 "0x%x mailbox[5] = 0x%x, comp_status "
3821 "= 0x%x, scsi_status = 0x%x\n",
3822 ha->rsp_ring_index, mailbox[5],
3823 le16_to_cpu(pkt->comp_status),
3824 le16_to_cpu(pkt->scsi_status));
3827 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3828 "0x%x, mailbox[5] = 0x%x\n",
3829 ha->rsp_ring_index, mailbox[5]);
3830 dprintk(2, "qla1280_isr: response packet data\n");
3831 qla1280_dump_buffer(2, (char *)pkt,
3832 RESPONSE_ENTRY_SIZE);
3835 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3836 dprintk(2, "status: Cmd %p, handle %i\n",
3837 ha->outstanding_cmds[pkt->handle]->cmd,
3839 if (pkt->entry_type == STATUS_TYPE)
3840 qla1280_status_entry(ha, pkt, done_q);
3842 qla1280_error_entry(ha, pkt, done_q);
3843 /* Adjust ring index. */
3844 ha->rsp_ring_index++;
3845 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3846 ha->rsp_ring_index = 0;
3847 ha->response_ring_ptr = ha->response_ring;
3849 ha->response_ring_ptr++;
3850 WRT_REG_WORD(®->mailbox5, ha->rsp_ring_index);
3855 LEAVE("qla1280_isr");
3860 * Processes asynchronous reset.
3863 * ha = adapter block pointer.
3866 qla1280_rst_aen(struct scsi_qla_host *ha)
3870 ENTER("qla1280_rst_aen");
3872 if (ha->flags.online && !ha->flags.reset_active &&
3873 !ha->flags.abort_isp_active) {
3874 ha->flags.reset_active = 1;
3875 while (ha->flags.reset_marker) {
3876 /* Issue marker command. */
3877 ha->flags.reset_marker = 0;
3878 for (bus = 0; bus < ha->ports &&
3879 !ha->flags.reset_marker; bus++) {
3880 if (ha->bus_settings[bus].reset_marker) {
3881 ha->bus_settings[bus].reset_marker = 0;
3882 qla1280_marker(ha, bus, 0, 0,
3889 LEAVE("qla1280_rst_aen");
3893 #if LINUX_VERSION_CODE < 0x020500
3898 qla1280_get_target_options(struct scsi_cmnd *cmd, struct scsi_qla_host *ha)
3900 unsigned char *result;
3902 int bus, target, lun;
3904 bus = SCSI_BUS_32(cmd);
3905 target = SCSI_TCN_32(cmd);
3906 lun = SCSI_LUN_32(cmd);
3909 * Make sure to not touch anything if someone is using the
3912 if (cmd->use_sg || (CMD_RESULT(cmd) >> 16) != DID_OK || lun)
3915 result = cmd->request_buffer;
3918 n->bus[bus].target[target].parameter.f.enable_wide = 0;
3919 n->bus[bus].target[target].parameter.f.enable_sync = 0;
3920 n->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
3922 if (result[7] & 0x60)
3923 n->bus[bus].target[target].parameter.f.enable_wide = 1;
3924 if (result[7] & 0x10)
3925 n->bus[bus].target[target].parameter.f.enable_sync = 1;
3926 if ((result[2] >= 3) && (result[4] + 5 > 56) &&
3928 n->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
3930 dprintk(2, "get_target_options(): wide %i, sync %i, ppr %i\n",
3931 n->bus[bus].target[target].parameter.f.enable_wide,
3932 n->bus[bus].target[target].parameter.f.enable_sync,
3933 n->bus[bus].target[target].ppr_1x160.flags.enable_ppr);
3938 * qla1280_status_entry
3939 * Processes received ISP status entry.
3942 * ha = adapter block pointer.
3943 * pkt = entry pointer.
3944 * done_q = done queue.
3947 qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3948 struct list_head *done_q)
3950 unsigned int bus, target, lun;
3953 struct scsi_cmnd *cmd;
3954 uint32_t handle = le32_to_cpu(pkt->handle);
3955 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3956 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3958 ENTER("qla1280_status_entry");
3960 /* Validate handle. */
3961 if (handle < MAX_OUTSTANDING_COMMANDS)
3962 sp = ha->outstanding_cmds[handle];
3967 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3971 /* Free outstanding command slot. */
3972 ha->outstanding_cmds[handle] = NULL;
3976 /* Generate LU queue on cntrl, target, LUN */
3977 bus = SCSI_BUS_32(cmd);
3978 target = SCSI_TCN_32(cmd);
3979 lun = SCSI_LUN_32(cmd);
3981 if (comp_status || scsi_status) {
3982 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3983 "0x%x, handle = 0x%x\n", comp_status,
3984 scsi_status, handle);
3987 /* Target busy or queue full */
3988 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3989 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3990 CMD_RESULT(cmd) = scsi_status & 0xff;
3993 /* Save ISP completion status */
3994 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3996 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
3997 if (comp_status != CS_ARS_FAILED) {
3998 uint16_t req_sense_length =
3999 le16_to_cpu(pkt->req_sense_length);
4000 if (req_sense_length < CMD_SNSLEN(cmd))
4001 sense_sz = req_sense_length;
4004 * scsi_cmnd->sense_buffer is
4005 * 64 bytes, why only copy 63?
4006 * This looks wrong! /Jes
4008 sense_sz = CMD_SNSLEN(cmd) - 1;
4010 memcpy(cmd->sense_buffer,
4011 &pkt->req_sense_data, sense_sz);
4014 memset(cmd->sense_buffer + sense_sz, 0,
4015 sizeof(cmd->sense_buffer) - sense_sz);
4017 dprintk(2, "qla1280_status_entry: Check "
4018 "condition Sense data, b %i, t %i, "
4019 "l %i\n", bus, target, lun);
4021 qla1280_dump_buffer(2,
4022 (char *)cmd->sense_buffer,
4027 /* Place command on done queue. */
4028 list_add_tail(&sp->list, done_q);
4030 LEAVE("qla1280_status_entry");
4034 * qla1280_error_entry
4035 * Processes error entry.
4038 * ha = adapter block pointer.
4039 * pkt = entry pointer.
4040 * done_q = done queue.
4043 qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
4044 struct list_head *done_q)
4047 uint32_t handle = le32_to_cpu(pkt->handle);
4049 ENTER("qla1280_error_entry");
4051 if (pkt->entry_status & BIT_3)
4052 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
4053 else if (pkt->entry_status & BIT_2)
4054 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
4055 else if (pkt->entry_status & BIT_1)
4056 dprintk(2, "qla1280_error_entry: FULL flag error\n");
4058 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
4060 /* Validate handle. */
4061 if (handle < MAX_OUTSTANDING_COMMANDS)
4062 sp = ha->outstanding_cmds[handle];
4067 /* Free outstanding command slot. */
4068 ha->outstanding_cmds[handle] = NULL;
4070 /* Bad payload or header */
4071 if (pkt->entry_status & (BIT_3 + BIT_2)) {
4072 /* Bad payload or header, set error status. */
4073 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
4074 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
4075 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
4076 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
4078 /* Set error status. */
4079 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
4082 /* Place command on done queue. */
4083 list_add_tail(&sp->list, done_q);
4085 #ifdef QLA_64BIT_PTR
4086 else if (pkt->entry_type == COMMAND_A64_TYPE) {
4087 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
4091 LEAVE("qla1280_error_entry");
4096 * Resets ISP and aborts all outstanding commands.
4099 * ha = adapter block pointer.
4105 qla1280_abort_isp(struct scsi_qla_host *ha)
4107 struct device_reg __iomem *reg = ha->iobase;
4113 ENTER("qla1280_abort_isp");
4115 if (ha->flags.abort_isp_active || !ha->flags.online)
4118 ha->flags.abort_isp_active = 1;
4120 /* Disable ISP interrupts. */
4121 qla1280_disable_intrs(ha);
4122 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
4123 RD_REG_WORD(®->id_l);
4125 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
4127 /* Dequeue all commands in outstanding command list. */
4128 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
4129 struct scsi_cmnd *cmd;
4130 sp = ha->outstanding_cmds[cnt];
4134 CMD_RESULT(cmd) = DID_RESET << 16;
4137 ha->outstanding_cmds[cnt] = NULL;
4139 (*cmd->scsi_done)(cmd);
4145 status = qla1280_load_firmware(ha);
4149 /* Setup adapter based on NVRAM parameters. */
4150 qla1280_nvram_config (ha);
4152 status = qla1280_init_rings(ha);
4156 /* Issue SCSI reset. */
4157 for (bus = 0; bus < ha->ports; bus++)
4158 qla1280_bus_reset(ha, bus);
4160 ha->flags.abort_isp_active = 0;
4164 "qla1280: ISP error recovery failed, board disabled");
4165 qla1280_reset_adapter(ha);
4166 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
4169 LEAVE("qla1280_abort_isp");
4175 * qla1280_debounce_register
4176 * Debounce register.
4179 * port = register address.
4185 qla1280_debounce_register(volatile u16 __iomem * addr)
4190 ret = RD_REG_WORD(addr);
4191 ret2 = RD_REG_WORD(addr);
4198 ret = RD_REG_WORD(addr);
4199 ret2 = RD_REG_WORD(addr);
4200 } while (ret != ret2);
4206 /************************************************************************
4207 * qla1280_check_for_dead_scsi_bus *
4209 * This routine checks for a dead SCSI bus *
4210 ************************************************************************/
4211 #define SET_SXP_BANK 0x0100
4212 #define SCSI_PHASE_INVALID 0x87FF
4214 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
4216 uint16_t config_reg, scsi_control;
4217 struct device_reg __iomem *reg = ha->iobase;
4219 if (ha->bus_settings[bus].scsi_bus_dead) {
4220 WRT_REG_WORD(®->host_cmd, HC_PAUSE_RISC);
4221 config_reg = RD_REG_WORD(®->cfg_1);
4222 WRT_REG_WORD(®->cfg_1, SET_SXP_BANK);
4223 scsi_control = RD_REG_WORD(®->scsiControlPins);
4224 WRT_REG_WORD(®->cfg_1, config_reg);
4225 WRT_REG_WORD(®->host_cmd, HC_RELEASE_RISC);
4227 if (scsi_control == SCSI_PHASE_INVALID) {
4228 ha->bus_settings[bus].scsi_bus_dead = 1;
4230 CMD_RESULT(cp) = DID_NO_CONNECT << 16;
4231 CMD_HANDLE(cp) = INVALID_HANDLE;
4232 /* ha->actthreads--; */
4234 (*(cp)->scsi_done)(cp);
4236 return 1; /* bus is dead */
4238 ha->bus_settings[bus].scsi_bus_dead = 0;
4239 ha->bus_settings[bus].failed_reset_count = 0;
4242 return 0; /* bus is not dead */
4246 qla1280_get_target_parameters(struct scsi_qla_host *ha,
4247 struct scsi_device *device)
4249 uint16_t mb[MAILBOX_REGISTER_COUNT];
4250 int bus, target, lun;
4252 bus = device->channel;
4253 target = device->id;
4257 mb[0] = MBC_GET_TARGET_PARAMETERS;
4258 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
4260 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
4263 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
4266 printk(" Sync: period %d, offset %d",
4267 (mb[3] & 0xff), (mb[3] >> 8));
4270 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
4275 if (DEV_SIMPLE_TAGS(device))
4276 printk(", Tagged queuing: depth %d", device->queue_depth);
4283 __qla1280_dump_buffer(char *b, int size)
4288 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
4289 "Bh Ch Dh Eh Fh\n");
4290 printk(KERN_DEBUG "---------------------------------------------"
4291 "------------------\n");
4293 for (cnt = 0; cnt < size;) {
4296 printk("0x%02x", c);
4307 /**************************************************************************
4308 * ql1280_print_scsi_cmd
4310 **************************************************************************/
4312 __qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
4314 struct scsi_qla_host *ha;
4315 struct Scsi_Host *host = CMD_HOST(cmd);
4317 /* struct scatterlist *sg; */
4320 ha = (struct scsi_qla_host *)host->hostdata;
4322 sp = (struct srb *)CMD_SP(cmd);
4323 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
4324 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4325 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
4328 for (i = 0; i < cmd->cmd_len; i++) {
4329 printk("0x%02x ", cmd->cmnd[i]);
4331 printk(" seg_cnt =%d\n", cmd->use_sg);
4332 printk(" request buffer=0x%p, request buffer len=0x%x\n",
4333 cmd->request_buffer, cmd->request_bufflen);
4336 sg = (struct scatterlist *) cmd->request_buffer;
4337 printk(" SG buffer: \n");
4338 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4340 printk(" tag=%d, transfersize=0x%x \n",
4341 cmd->tag, cmd->transfersize);
4342 printk(" Pid=%li, SP=0x%p\n", cmd->pid, CMD_SP(cmd));
4343 printk(" underflow size = 0x%x, direction=0x%x\n",
4344 cmd->underflow, cmd->sc_data_direction);
4347 /**************************************************************************
4348 * ql1280_dump_device
4350 **************************************************************************/
4352 ql1280_dump_device(struct scsi_qla_host *ha)
4355 struct scsi_cmnd *cp;
4359 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4361 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4362 if ((sp = ha->outstanding_cmds[i]) == NULL)
4364 if ((cp = sp->cmd) == NULL)
4366 qla1280_print_scsi_cmd(1, cp);
4381 struct setup_tokens {
4386 static struct setup_tokens setup_token[] __initdata =
4388 { "nvram", TOKEN_NVRAM },
4389 { "sync", TOKEN_SYNC },
4390 { "wide", TOKEN_WIDE },
4391 { "ppr", TOKEN_PPR },
4392 { "verbose", TOKEN_VERBOSE },
4393 { "debug", TOKEN_DEBUG },
4397 /**************************************************************************
4400 * Handle boot parameters. This really needs to be changed so one
4401 * can specify per adapter parameters.
4402 **************************************************************************/
4404 qla1280_setup(char *s)
4412 while (cp && (ptr = strchr(cp, ':'))) {
4414 if (!strcmp(ptr, "yes")) {
4417 } else if (!strcmp(ptr, "no")) {
4421 val = simple_strtoul(ptr, &ptr, 0);
4423 switch ((toke = qla1280_get_token(cp))) {
4426 driver_setup.no_nvram = 1;
4430 driver_setup.no_sync = 1;
4431 else if (val != 0x10000)
4432 driver_setup.sync_mask = val;
4436 driver_setup.no_wide = 1;
4437 else if (val != 0x10000)
4438 driver_setup.wide_mask = val;
4442 driver_setup.no_ppr = 1;
4443 else if (val != 0x10000)
4444 driver_setup.ppr_mask = val;
4447 qla1280_verbose = val;
4450 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4454 cp = strchr(ptr, ';');
4466 qla1280_get_token(char *str)
4472 len = sizeof(setup_token)/sizeof(struct setup_tokens);
4474 sep = strchr(str, ':');
4477 for (i = 0; i < len; i++){
4479 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4480 ret = setup_token[i].val;
4489 #if LINUX_VERSION_CODE >= 0x020600
4490 static struct scsi_host_template qla1280_driver_template = {
4491 .module = THIS_MODULE,
4492 .proc_name = "qla1280",
4493 .name = "Qlogic ISP 1280/12160",
4494 .info = qla1280_info,
4495 .slave_configure = qla1280_slave_configure,
4496 .queuecommand = qla1280_queuecommand,
4497 .eh_abort_handler = qla1280_eh_abort,
4498 .eh_device_reset_handler= qla1280_eh_device_reset,
4499 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4500 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4501 .bios_param = qla1280_biosparam,
4502 .can_queue = 0xfffff,
4504 .sg_tablesize = SG_ALL,
4506 .use_clustering = ENABLE_CLUSTERING,
4509 static Scsi_Host_Template qla1280_driver_template = {
4510 .proc_name = "qla1280",
4511 .name = "Qlogic ISP 1280/12160",
4512 .detect = qla1280_detect,
4513 .release = qla1280_release,
4514 .info = qla1280_info,
4515 .queuecommand = qla1280_queuecommand,
4516 .eh_abort_handler = qla1280_eh_abort,
4517 .eh_device_reset_handler= qla1280_eh_device_reset,
4518 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4519 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4520 .bios_param = qla1280_biosparam_old,
4521 .can_queue = 0xfffff,
4523 .sg_tablesize = SG_ALL,
4525 .use_clustering = ENABLE_CLUSTERING,
4526 .use_new_eh_code = 1,
4530 static int __devinit
4531 qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4533 int devnum = id->driver_data;
4534 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4535 struct Scsi_Host *host;
4536 struct scsi_qla_host *ha;
4537 int error = -ENODEV;
4539 /* Bypass all AMI SUBSYS VENDOR IDs */
4540 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4542 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4546 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4547 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4549 if (pci_enable_device(pdev)) {
4551 "qla1280: Failed to enabled pci device, aborting.\n");
4555 pci_set_master(pdev);
4558 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4561 "qla1280: Failed to register host, aborting.\n");
4562 goto error_disable_device;
4565 ha = (struct scsi_qla_host *)host->hostdata;
4566 memset(ha, 0, sizeof(struct scsi_qla_host));
4569 ha->devnum = devnum; /* specifies microcode load address */
4571 #ifdef QLA_64BIT_PTR
4572 if (pci_set_dma_mask(ha->pdev, (dma_addr_t) ~ 0ULL)) {
4573 if (pci_set_dma_mask(ha->pdev, 0xffffffff)) {
4574 printk(KERN_WARNING "scsi(%li): Unable to set a "
4575 "suitable DMA mask - aborting\n", ha->host_no);
4577 goto error_free_irq;
4580 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4583 if (pci_set_dma_mask(ha->pdev, 0xffffffff)) {
4584 printk(KERN_WARNING "scsi(%li): Unable to set a "
4585 "suitable DMA mask - aborting\n", ha->host_no);
4587 goto error_free_irq;
4591 ha->request_ring = pci_alloc_consistent(ha->pdev,
4592 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4594 if (!ha->request_ring) {
4595 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4596 goto error_put_host;
4599 ha->response_ring = pci_alloc_consistent(ha->pdev,
4600 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4602 if (!ha->response_ring) {
4603 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4604 goto error_free_request_ring;
4607 ha->ports = bdp->numPorts;
4610 ha->host_no = host->host_no;
4612 host->irq = pdev->irq;
4613 host->max_channel = bdp->numPorts - 1;
4614 host->max_lun = MAX_LUNS - 1;
4615 host->max_id = MAX_TARGETS;
4616 host->max_sectors = 1024;
4617 host->unique_id = host->host_no;
4619 #if LINUX_VERSION_CODE < 0x020545
4620 host->select_queue_depths = qla1280_select_queue_depth;
4625 #if MEMORY_MAPPED_IO
4626 ha->mmpbase = ioremap(pci_resource_start(ha->pdev, 1),
4627 pci_resource_len(ha->pdev, 1));
4629 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4630 goto error_free_response_ring;
4633 host->base = (unsigned long)ha->mmpbase;
4634 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4636 host->io_port = pci_resource_start(ha->pdev, 0);
4637 if (!request_region(host->io_port, 0xff, "qla1280")) {
4638 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4639 "0x%04lx-0x%04lx - already in use\n",
4640 host->io_port, host->io_port + 0xff);
4641 goto error_free_response_ring;
4644 ha->iobase = (struct device_reg *)host->io_port;
4647 INIT_LIST_HEAD(&ha->done_q);
4649 /* Disable ISP interrupts. */
4650 qla1280_disable_intrs(ha);
4652 if (request_irq(pdev->irq, qla1280_intr_handler, SA_SHIRQ,
4654 printk("qla1280 : Failed to reserve interrupt %d already "
4655 "in use\n", pdev->irq);
4656 goto error_release_region;
4659 /* load the F/W, read paramaters, and init the H/W */
4660 if (qla1280_initialize_adapter(ha)) {
4661 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4662 goto error_free_irq;
4665 /* set our host ID (need to do something about our two IDs) */
4666 host->this_id = ha->bus_settings[0].id;
4668 pci_set_drvdata(pdev, host);
4670 #if LINUX_VERSION_CODE >= 0x020600
4671 error = scsi_add_host(host, &pdev->dev);
4673 goto error_disable_adapter;
4674 scsi_scan_host(host);
4676 scsi_set_pci_device(host, pdev);
4681 #if LINUX_VERSION_CODE >= 0x020600
4682 error_disable_adapter:
4683 qla1280_disable_intrs(ha);
4686 free_irq(pdev->irq, ha);
4687 error_release_region:
4688 #if MEMORY_MAPPED_IO
4689 iounmap(ha->mmpbase);
4691 release_region(host->io_port, 0xff);
4693 error_free_response_ring:
4694 pci_free_consistent(ha->pdev,
4695 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
4696 ha->response_ring, ha->response_dma);
4697 error_free_request_ring:
4698 pci_free_consistent(ha->pdev,
4699 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
4700 ha->request_ring, ha->request_dma);
4702 scsi_host_put(host);
4703 error_disable_device:
4704 pci_disable_device(pdev);
4710 static void __devexit
4711 qla1280_remove_one(struct pci_dev *pdev)
4713 struct Scsi_Host *host = pci_get_drvdata(pdev);
4714 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4716 #if LINUX_VERSION_CODE >= 0x020600
4717 scsi_remove_host(host);
4720 qla1280_disable_intrs(ha);
4722 free_irq(pdev->irq, ha);
4724 #if MEMORY_MAPPED_IO
4725 iounmap(ha->mmpbase);
4727 release_region(host->io_port, 0xff);
4730 pci_free_consistent(ha->pdev,
4731 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4732 ha->request_ring, ha->request_dma);
4733 pci_free_consistent(ha->pdev,
4734 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4735 ha->response_ring, ha->response_dma);
4737 pci_disable_device(pdev);
4739 scsi_host_put(host);
4742 #if LINUX_VERSION_CODE >= 0x020600
4743 static struct pci_driver qla1280_pci_driver = {
4745 .id_table = qla1280_pci_tbl,
4746 .probe = qla1280_probe_one,
4747 .remove = __devexit_p(qla1280_remove_one),
4753 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4755 "qla1280: struct srb too big, aborting\n");
4761 * If we are called as a module, the qla1280 pointer may not be null
4762 * and it would point to our bootup string, just like on the lilo
4763 * command line. IF not NULL, then process this config string with
4767 * To add options at boot time add a line to your lilo.conf file like:
4768 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4769 * which will result in the first four devices on the first two
4770 * controllers being set to a tagged queue depth of 32.
4773 qla1280_setup(qla1280);
4776 return pci_module_init(&qla1280_pci_driver);
4782 pci_unregister_driver(&qla1280_pci_driver);
4785 module_init(qla1280_init);
4786 module_exit(qla1280_exit);
4789 # define driver_template qla1280_driver_template
4790 # include "scsi_module.c"
4793 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4794 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4795 MODULE_LICENSE("GPL");
4796 MODULE_VERSION(QLA1280_VERSION);
4799 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4800 * Emacs will notice this stuff at the end of the file and automatically
4801 * adjust the settings for this buffer only. This must remain at the end
4803 * ---------------------------------------------------------------------------