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
);
999 ha
->flags
.in_reset
= 1;
1000 if (qla1280_verbose
)
1002 "scsi(%ld:%d:%d:%d): Queueing abort device "
1003 "command.\n", ha
->host_no
, bus
, target
, lun
);
1004 if (qla1280_abort_device(ha
, bus
, target
, lun
) == 0)
1009 if (qla1280_verbose
)
1011 "scsi(%ld:%d:%d:%d): Queueing device reset "
1012 "command.\n", ha
->host_no
, bus
, target
, lun
);
1013 ha
->flags
.in_reset
= 1;
1014 if (qla1280_device_reset(ha
, bus
, target
) == 0)
1019 if (qla1280_verbose
)
1020 printk(KERN_INFO
"qla1280(%ld:%d): Issuing BUS "
1021 "DEVICE RESET\n", ha
->host_no
, bus
);
1022 ha
->flags
.in_reset
= 1;
1023 if (qla1280_bus_reset(ha
, bus
== 0))
1030 if (qla1280_verbose
) {
1032 "scsi(%ld): Issued ADAPTER RESET\n",
1034 printk(KERN_INFO
"scsi(%ld): I/O processing will "
1035 "continue automatically\n", ha
->host_no
);
1037 ha
->flags
.reset_active
= 1;
1039 * We restarted all of the commands automatically, so the
1040 * mid-level code can expect completions momentitarily.
1042 if (qla1280_abort_isp(ha
) == 0)
1045 ha
->flags
.reset_active
= 0;
1048 if (!list_empty(&ha
->done_q
))
1050 ha
->flags
.in_reset
= 0;
1052 /* If we didn't manage to issue the action, or we have no
1053 * command to wait for, exit here */
1054 if (result
== FAILED
|| handle
== NULL
||
1055 handle
== (unsigned char *)INVALID_HANDLE
) {
1057 * Clear completion queue to avoid qla1280_done() trying
1058 * to complete the command at a later stage after we
1059 * have exited the current context
1065 /* set up a timer just in case we're really jammed */
1067 timer
.expires
= jiffies
+ 4*HZ
;
1068 timer
.data
= (unsigned long)cmd
;
1069 timer
.function
= qla1280_error_wait_timeout
;
1072 /* wait for the action to complete (or the timer to expire) */
1073 spin_unlock_irq(HOST_LOCK
);
1074 wait_for_completion(&wait
);
1075 del_timer_sync(&timer
);
1076 spin_lock_irq(HOST_LOCK
);
1079 /* the only action we might get a fail for is abort */
1080 if (action
== ABORT_COMMAND
) {
1081 if(sp
->flags
& SRB_ABORTED
)
1088 dprintk(1, "RESET returning %d\n", result
);
1090 LEAVE("qla1280_error_action");
1094 /**************************************************************************
1096 * Abort the specified SCSI command(s).
1097 **************************************************************************/
1099 qla1280_eh_abort(struct scsi_cmnd
* cmd
)
1103 spin_lock_irq(cmd
->device
->host
->host_lock
);
1104 rc
= qla1280_error_action(cmd
, ABORT_COMMAND
);
1105 spin_unlock_irq(cmd
->device
->host
->host_lock
);
1110 /**************************************************************************
1111 * qla1280_device_reset
1112 * Reset the specified SCSI device
1113 **************************************************************************/
1115 qla1280_eh_device_reset(struct scsi_cmnd
*cmd
)
1117 return qla1280_error_action(cmd
, DEVICE_RESET
);
1120 /**************************************************************************
1122 * Reset the specified bus.
1123 **************************************************************************/
1125 qla1280_eh_bus_reset(struct scsi_cmnd
*cmd
)
1127 return qla1280_error_action(cmd
, BUS_RESET
);
1130 /**************************************************************************
1131 * qla1280_adapter_reset
1132 * Reset the specified adapter (both channels)
1133 **************************************************************************/
1135 qla1280_eh_adapter_reset(struct scsi_cmnd
*cmd
)
1137 return qla1280_error_action(cmd
, ADAPTER_RESET
);
1141 qla1280_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
,
1142 sector_t capacity
, int geom
[])
1144 int heads
, sectors
, cylinders
;
1148 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
1149 if (cylinders
> 1024) {
1152 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
1153 /* if (cylinders > 1023)
1154 cylinders = 1023; */
1159 geom
[2] = cylinders
;
1164 #if LINUX_VERSION_CODE < 0x020600
1166 qla1280_detect(Scsi_Host_Template
*template)
1168 struct pci_device_id
*id
= &qla1280_pci_tbl
[0];
1169 struct pci_dev
*pdev
= NULL
;
1172 if (sizeof(struct srb
) > sizeof(Scsi_Pointer
)) {
1174 "qla1280: struct srb too big, aborting\n");
1178 if ((DMA_BIDIRECTIONAL
!= PCI_DMA_BIDIRECTIONAL
) ||
1179 (DMA_TO_DEVICE
!= PCI_DMA_TODEVICE
) ||
1180 (DMA_FROM_DEVICE
!= PCI_DMA_FROMDEVICE
) ||
1181 (DMA_NONE
!= PCI_DMA_NONE
)) {
1183 "qla1280: dma direction bits don't match\n");
1189 * If we are called as a module, the qla1280 pointer may not be null
1190 * and it would point to our bootup string, just like on the lilo
1191 * command line. IF not NULL, then process this config string with
1195 * To add options at boot time add a line to your lilo.conf file like:
1196 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
1197 * which will result in the first four devices on the first two
1198 * controllers being set to a tagged queue depth of 32.
1201 qla1280_setup(qla1280
);
1204 /* First Initialize QLA12160 on PCI Bus 1 Dev 2 */
1205 while ((pdev
= pci_find_device(id
->vendor
, id
->device
, pdev
))) {
1206 if (pdev
->bus
->number
== 1 && PCI_SLOT(pdev
->devfn
) == 2) {
1207 if (!qla1280_probe_one(pdev
, id
))
1213 /* Try and find each different type of adapter we support */
1214 for (id
= &qla1280_pci_tbl
[0]; id
->device
; id
++) {
1215 while ((pdev
= pci_find_device(id
->vendor
, id
->device
, pdev
))) {
1217 * skip QLA12160 already initialized on
1218 * PCI Bus 1 Dev 2 since we already initialized
1221 if (id
->device
== PCI_DEVICE_ID_QLOGIC_ISP12160
&&
1222 pdev
->bus
->number
== 1 &&
1223 PCI_SLOT(pdev
->devfn
) == 2)
1226 if (!qla1280_probe_one(pdev
, id
))
1235 * This looks a bit ugly as we could just pass down host to
1236 * qla1280_remove_one, but I want to keep qla1280_release purely a wrapper
1237 * around pci_driver::remove as used from 2.6 onwards.
1240 qla1280_release(struct Scsi_Host
*host
)
1242 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
1244 qla1280_remove_one(ha
->pdev
);
1249 qla1280_biosparam_old(Disk
* disk
, kdev_t dev
, int geom
[])
1251 return qla1280_biosparam(disk
->device
, NULL
, disk
->capacity
, geom
);
1255 /**************************************************************************
1256 * qla1280_intr_handler
1257 * Handles the H/W interrupt
1258 **************************************************************************/
1260 qla1280_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
1262 struct scsi_qla_host
*ha
;
1263 struct device_reg __iomem
*reg
;
1267 ENTER_INTR ("qla1280_intr_handler");
1268 ha
= (struct scsi_qla_host
*)dev_id
;
1270 spin_lock(HOST_LOCK
);
1275 WRT_REG_WORD(®
->ictrl
, 0); /* disable our interrupt. */
1277 data
= qla1280_debounce_register(®
->istatus
);
1278 /* Check for pending interrupts. */
1279 if (data
& RISC_INT
) {
1280 qla1280_isr(ha
, &ha
->done_q
);
1283 if (!list_empty(&ha
->done_q
))
1286 spin_unlock(HOST_LOCK
);
1288 /* enable our interrupt. */
1289 WRT_REG_WORD(®
->ictrl
, (ISP_EN_INT
| ISP_EN_RISC
));
1291 LEAVE_INTR("qla1280_intr_handler");
1292 return IRQ_RETVAL(handled
);
1297 qla1280_set_target_parameters(struct scsi_qla_host
*ha
, int bus
, int target
)
1300 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1306 mr
= BIT_3
| BIT_2
| BIT_1
| BIT_0
;
1308 /* Set Target Parameters. */
1309 mb
[0] = MBC_SET_TARGET_PARAMETERS
;
1310 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
1313 mb
[2] = (nv
->bus
[bus
].target
[target
].parameter
.c
<< 8);
1315 if (IS_ISP1x160(ha
)) {
1316 mb
[2] |= nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
<< 5;
1317 mb
[3] = (nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
<< 8) |
1318 nv
->bus
[bus
].target
[target
].sync_period
;
1319 mb
[6] = (nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_options
<< 8) |
1320 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_bus_width
;
1323 mb
[3] = (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
<< 8) |
1324 nv
->bus
[bus
].target
[target
].sync_period
;
1327 status
= qla1280_mailbox_command(ha
, mr
, &mb
[0]);
1330 printk(KERN_WARNING
"scsi(%ld:%i:%i): "
1331 "qla1280_set_target_parameters() failed\n",
1332 ha
->host_no
, bus
, target
);
1337 /**************************************************************************
1338 * qla1280_slave_configure
1341 * Determines the queue depth for a given device. There are two ways
1342 * a queue depth can be obtained for a tagged queueing device. One
1343 * way is the default queue depth which is determined by whether
1344 * If it is defined, then it is used
1345 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1346 * default queue depth (dependent on the number of hardware SCBs).
1347 **************************************************************************/
1349 qla1280_slave_configure(struct scsi_device
*device
)
1351 struct scsi_qla_host
*ha
;
1352 int default_depth
= 3;
1353 int bus
= device
->channel
;
1354 int target
= device
->id
;
1357 unsigned long flags
;
1359 ha
= (struct scsi_qla_host
*)device
->host
->hostdata
;
1362 if (qla1280_check_for_dead_scsi_bus(ha
, bus
))
1365 if (device
->tagged_supported
&&
1366 (ha
->bus_settings
[bus
].qtag_enables
& (BIT_0
<< target
))) {
1367 scsi_adjust_queue_depth(device
, MSG_ORDERED_TAG
,
1368 ha
->bus_settings
[bus
].hiwat
);
1370 scsi_adjust_queue_depth(device
, 0, default_depth
);
1373 #if LINUX_VERSION_CODE > 0x020500
1374 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= device
->sdtr
;
1375 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= device
->wdtr
;
1376 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= device
->ppr
;
1379 if (driver_setup
.no_sync
||
1380 (driver_setup
.sync_mask
&&
1381 (~driver_setup
.sync_mask
& (1 << target
))))
1382 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 0;
1383 if (driver_setup
.no_wide
||
1384 (driver_setup
.wide_mask
&&
1385 (~driver_setup
.wide_mask
& (1 << target
))))
1386 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 0;
1387 if (IS_ISP1x160(ha
)) {
1388 if (driver_setup
.no_ppr
||
1389 (driver_setup
.ppr_mask
&&
1390 (~driver_setup
.ppr_mask
& (1 << target
))))
1391 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 0;
1394 spin_lock_irqsave(HOST_LOCK
, flags
);
1395 if (nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
)
1396 status
= qla1280_set_target_parameters(ha
, bus
, target
);
1397 qla1280_get_target_parameters(ha
, device
);
1398 spin_unlock_irqrestore(HOST_LOCK
, flags
);
1402 #if LINUX_VERSION_CODE < 0x020545
1403 /**************************************************************************
1404 * qla1280_select_queue_depth
1406 * Sets the queue depth for each SCSI device hanging off the input
1407 * host adapter. We use a queue depth of 2 for devices that do not
1408 * support tagged queueing.
1409 **************************************************************************/
1411 qla1280_select_queue_depth(struct Scsi_Host
*host
, struct scsi_device
*sdev_q
)
1413 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
1414 struct scsi_device
*sdev
;
1416 ENTER("qla1280_select_queue_depth");
1417 for (sdev
= sdev_q
; sdev
; sdev
= sdev
->next
)
1418 if (sdev
->host
== host
)
1419 qla1280_slave_configure(sdev
);
1422 qla1280_check_for_dead_scsi_bus(ha
, sdev_q
->channel
);
1423 LEAVE("qla1280_select_queue_depth");
1429 * Process completed commands.
1432 * ha = adapter block pointer.
1433 * done_q = done queue.
1436 qla1280_done(struct scsi_qla_host
*ha
)
1439 struct list_head
*done_q
;
1440 int bus
, target
, lun
;
1441 struct scsi_cmnd
*cmd
;
1443 ENTER("qla1280_done");
1445 done_q
= &ha
->done_q
;
1447 while (!list_empty(done_q
)) {
1448 sp
= list_entry(done_q
->next
, struct srb
, list
);
1450 list_del(&sp
->list
);
1453 bus
= SCSI_BUS_32(cmd
);
1454 target
= SCSI_TCN_32(cmd
);
1455 lun
= SCSI_LUN_32(cmd
);
1457 switch ((CMD_RESULT(cmd
) >> 16)) {
1459 /* Issue marker command. */
1460 qla1280_marker(ha
, bus
, target
, 0, MK_SYNC_ID
);
1463 sp
->flags
&= ~SRB_ABORT_PENDING
;
1464 sp
->flags
|= SRB_ABORTED
;
1465 if (sp
->flags
& SRB_TIMEOUT
)
1466 CMD_RESULT(sp
->cmd
) = DID_TIME_OUT
<< 16;
1472 /* Release memory used for this I/O */
1474 pci_unmap_sg(ha
->pdev
, cmd
->request_buffer
,
1475 cmd
->use_sg
, cmd
->sc_data_direction
);
1476 } else if (cmd
->request_bufflen
) {
1477 pci_unmap_single(ha
->pdev
, sp
->saved_dma_handle
,
1478 cmd
->request_bufflen
,
1479 cmd
->sc_data_direction
);
1482 /* Call the mid-level driver interrupt handler */
1483 CMD_HANDLE(sp
->cmd
) = (unsigned char *)INVALID_HANDLE
;
1486 #if LINUX_VERSION_CODE < 0x020500
1487 if (cmd
->cmnd
[0] == INQUIRY
)
1488 qla1280_get_target_options(cmd
, ha
);
1490 (*(cmd
)->scsi_done
)(cmd
);
1492 if(sp
->wait
!= NULL
)
1495 LEAVE("qla1280_done");
1499 * Translates a ISP error to a Linux SCSI error
1502 qla1280_return_status(struct response
* sts
, struct scsi_cmnd
*cp
)
1504 int host_status
= DID_ERROR
;
1505 uint16_t comp_status
= le16_to_cpu(sts
->comp_status
);
1506 uint16_t state_flags
= le16_to_cpu(sts
->state_flags
);
1507 uint16_t residual_length
= le16_to_cpu(sts
->residual_length
);
1508 uint16_t scsi_status
= le16_to_cpu(sts
->scsi_status
);
1509 #if DEBUG_QLA1280_INTR
1510 static char *reason
[] = {
1522 #endif /* DEBUG_QLA1280_INTR */
1524 ENTER("qla1280_return_status");
1526 #if DEBUG_QLA1280_INTR
1528 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1533 switch (comp_status
) {
1535 host_status
= DID_OK
;
1539 if (!(state_flags
& SF_GOT_BUS
))
1540 host_status
= DID_NO_CONNECT
;
1541 else if (!(state_flags
& SF_GOT_TARGET
))
1542 host_status
= DID_BAD_TARGET
;
1543 else if (!(state_flags
& SF_SENT_CDB
))
1544 host_status
= DID_ERROR
;
1545 else if (!(state_flags
& SF_TRANSFERRED_DATA
))
1546 host_status
= DID_ERROR
;
1547 else if (!(state_flags
& SF_GOT_STATUS
))
1548 host_status
= DID_ERROR
;
1549 else if (!(state_flags
& SF_GOT_SENSE
))
1550 host_status
= DID_ERROR
;
1554 host_status
= DID_RESET
;
1558 host_status
= DID_ABORT
;
1562 host_status
= DID_TIME_OUT
;
1565 case CS_DATA_OVERRUN
:
1566 dprintk(2, "Data overrun 0x%x\n", residual_length
);
1567 dprintk(2, "qla1280_isr: response packet data\n");
1568 qla1280_dump_buffer(2, (char *)sts
, RESPONSE_ENTRY_SIZE
);
1569 host_status
= DID_ERROR
;
1572 case CS_DATA_UNDERRUN
:
1573 if ((cp
->request_bufflen
- residual_length
) <
1576 "scsi: Underflow detected - retrying "
1578 host_status
= DID_ERROR
;
1580 host_status
= DID_OK
;
1584 host_status
= DID_ERROR
;
1588 #if DEBUG_QLA1280_INTR
1589 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1590 reason
[host_status
], scsi_status
);
1593 LEAVE("qla1280_return_status");
1595 return (scsi_status
& 0xff) | (host_status
<< 16);
1598 /****************************************************************************/
1599 /* QLogic ISP1280 Hardware Support Functions. */
1600 /****************************************************************************/
1603 * qla2100_enable_intrs
1604 * qla2100_disable_intrs
1607 * ha = adapter block pointer.
1613 qla1280_enable_intrs(struct scsi_qla_host
*ha
)
1615 struct device_reg __iomem
*reg
;
1618 /* enable risc and host interrupts */
1619 WRT_REG_WORD(®
->ictrl
, (ISP_EN_INT
| ISP_EN_RISC
));
1620 RD_REG_WORD(®
->ictrl
); /* PCI Posted Write flush */
1621 ha
->flags
.ints_enabled
= 1;
1625 qla1280_disable_intrs(struct scsi_qla_host
*ha
)
1627 struct device_reg __iomem
*reg
;
1630 /* disable risc and host interrupts */
1631 WRT_REG_WORD(®
->ictrl
, 0);
1632 RD_REG_WORD(®
->ictrl
); /* PCI Posted Write flush */
1633 ha
->flags
.ints_enabled
= 0;
1637 * qla1280_initialize_adapter
1641 * ha = adapter block pointer.
1646 static int __devinit
1647 qla1280_initialize_adapter(struct scsi_qla_host
*ha
)
1649 struct device_reg __iomem
*reg
;
1652 #if LINUX_VERSION_CODE > 0x020500
1653 unsigned long flags
;
1656 ENTER("qla1280_initialize_adapter");
1658 /* Clear adapter flags. */
1659 ha
->flags
.online
= 0;
1660 ha
->flags
.disable_host_adapter
= 0;
1661 ha
->flags
.reset_active
= 0;
1662 ha
->flags
.abort_isp_active
= 0;
1664 ha
->flags
.ints_enabled
= 0;
1665 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1666 if (ia64_platform_is("sn2")) {
1667 printk(KERN_INFO
"scsi(%li): Enabling SN2 PCI DMA "
1668 "dual channel lockup workaround\n", ha
->host_no
);
1669 ha
->flags
.use_pci_vchannel
= 1;
1670 driver_setup
.no_nvram
= 1;
1674 /* TODO: implement support for the 1040 nvram format */
1676 driver_setup
.no_nvram
= 1;
1678 dprintk(1, "Configure PCI space for adapter...\n");
1682 /* Insure mailbox registers are free. */
1683 WRT_REG_WORD(®
->semaphore
, 0);
1684 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
1685 WRT_REG_WORD(®
->host_cmd
, HC_CLR_HOST_INT
);
1686 RD_REG_WORD(®
->host_cmd
);
1688 if (qla1280_read_nvram(ha
)) {
1689 dprintk(2, "qla1280_initialize_adapter: failed to read "
1693 #if LINUX_VERSION_CODE >= 0x020500
1695 * It's necessary to grab the spin here as qla1280_mailbox_command
1696 * needs to be able to drop the lock unconditionally to wait
1698 * In 2.4 ->detect is called with the io_request_lock held.
1700 spin_lock_irqsave(HOST_LOCK
, flags
);
1703 status
= qla1280_load_firmware(ha
);
1705 printk(KERN_ERR
"scsi(%li): initialize: pci probe failed!\n",
1710 /* Setup adapter based on NVRAM parameters. */
1711 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha
->host_no
);
1712 qla1280_nvram_config(ha
);
1714 if (ha
->flags
.disable_host_adapter
) {
1719 status
= qla1280_init_rings(ha
);
1723 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1724 for (bus
= 0; bus
< ha
->ports
; bus
++) {
1725 if (!ha
->bus_settings
[bus
].disable_scsi_reset
&&
1726 qla1280_bus_reset(ha
, bus
) &&
1727 qla1280_bus_reset(ha
, bus
))
1728 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
1731 ha
->flags
.online
= 1;
1733 #if LINUX_VERSION_CODE >= 0x020500
1734 spin_unlock_irqrestore(HOST_LOCK
, flags
);
1737 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1739 LEAVE("qla1280_initialize_adapter");
1746 * Checks if present version of RISC firmware is older than
1750 * ha = adapter block pointer.
1753 * 0 = firmware does not need to be loaded.
1756 qla1280_isp_firmware(struct scsi_qla_host
*ha
)
1758 struct nvram
*nv
= (struct nvram
*) ha
->response_ring
;
1759 int status
= 0; /* dg 2/27 always loads RISC */
1760 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1762 ENTER("qla1280_isp_firmware");
1764 dprintk(1, "scsi(%li): Determining if RISC is loaded\n", ha
->host_no
);
1766 /* Bad NVRAM data, load RISC code. */
1767 if (!ha
->nvram_valid
) {
1768 ha
->flags
.disable_risc_code_load
= 0;
1770 ha
->flags
.disable_risc_code_load
=
1771 nv
->cntr_flags_1
.disable_loading_risc_code
;
1773 if (ha
->flags
.disable_risc_code_load
) {
1774 dprintk(3, "qla1280_isp_firmware: Telling RISC to verify "
1775 "checksum of loaded BIOS code.\n");
1777 /* Verify checksum of loaded RISC code. */
1778 mb
[0] = MBC_VERIFY_CHECKSUM
;
1779 /* mb[1] = ql12_risc_code_addr01; */
1780 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1783 qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]))) {
1784 /* Start firmware execution. */
1785 dprintk(3, "qla1280_isp_firmware: Startng F/W "
1788 mb
[0] = MBC_EXECUTE_FIRMWARE
;
1789 /* mb[1] = ql12_risc_code_addr01; */
1790 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1791 qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
1793 printk(KERN_INFO
"qla1280: RISC checksum failed.\n");
1795 dprintk(1, "qla1280: NVRAM configured to load RISC load.\n");
1800 dprintk(2, "qla1280_isp_firmware: **** Load RISC code ****\n");
1802 LEAVE("qla1280_isp_firmware");
1808 * Test chip for proper operation.
1811 * ha = adapter block pointer.
1817 qla1280_chip_diag(struct scsi_qla_host
*ha
)
1819 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1820 struct device_reg __iomem
*reg
= ha
->iobase
;
1824 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®
->id_l
);
1826 dprintk(1, "scsi(%ld): Verifying chip\n", ha
->host_no
);
1828 /* Soft reset chip and wait for it to finish. */
1829 WRT_REG_WORD(®
->ictrl
, ISP_RESET
);
1832 * We can't do a traditional PCI write flush here by reading
1833 * back the register. The card will not respond once the reset
1834 * is in action and we end up with a machine check exception
1835 * instead. Nothing to do but wait and hope for the best.
1836 * A portable pci_write_flush(pdev) call would be very useful here.
1839 data
= qla1280_debounce_register(®
->ictrl
);
1841 * Yet another QLogic gem ;-(
1843 for (cnt
= 1000000; cnt
&& data
& ISP_RESET
; cnt
--) {
1845 data
= RD_REG_WORD(®
->ictrl
);
1851 /* Reset register cleared by chip reset. */
1852 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1854 WRT_REG_WORD(®
->cfg_1
, 0);
1856 /* Reset RISC and disable BIOS which
1857 allows RISC to execute out of RAM. */
1858 WRT_REG_WORD(®
->host_cmd
, HC_RESET_RISC
|
1859 HC_RELEASE_RISC
| HC_DISABLE_BIOS
);
1861 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
1862 data
= qla1280_debounce_register(®
->mailbox0
);
1865 * I *LOVE* this code!
1867 for (cnt
= 1000000; cnt
&& data
== MBS_BUSY
; cnt
--) {
1869 data
= RD_REG_WORD(®
->mailbox0
);
1875 /* Check product ID of chip */
1876 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1878 if (RD_REG_WORD(®
->mailbox1
) != PROD_ID_1
||
1879 (RD_REG_WORD(®
->mailbox2
) != PROD_ID_2
&&
1880 RD_REG_WORD(®
->mailbox2
) != PROD_ID_2a
) ||
1881 RD_REG_WORD(®
->mailbox3
) != PROD_ID_3
||
1882 RD_REG_WORD(®
->mailbox4
) != PROD_ID_4
) {
1883 printk(KERN_INFO
"qla1280: Wrong product ID = "
1884 "0x%x,0x%x,0x%x,0x%x\n",
1885 RD_REG_WORD(®
->mailbox1
),
1886 RD_REG_WORD(®
->mailbox2
),
1887 RD_REG_WORD(®
->mailbox3
),
1888 RD_REG_WORD(®
->mailbox4
));
1893 * Enable ints early!!!
1895 qla1280_enable_intrs(ha
);
1897 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1898 /* Wrap Incoming Mailboxes Test. */
1899 mb
[0] = MBC_MAILBOX_REGISTER_TEST
;
1908 status
= qla1280_mailbox_command(ha
, 0xff, mb
);
1912 if (mb
[1] != 0xAAAA || mb
[2] != 0x5555 || mb
[3] != 0xAA55 ||
1913 mb
[4] != 0x55AA || mb
[5] != 0xA5A5 || mb
[6] != 0x5A5A ||
1915 printk(KERN_INFO
"qla1280: Failed mbox check\n");
1919 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1922 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1927 qla1280_load_firmware_pio(struct scsi_qla_host
*ha
)
1929 uint16_t risc_address
, *risc_code_address
, risc_code_size
;
1930 uint16_t mb
[MAILBOX_REGISTER_COUNT
], i
;
1933 /* Load RISC code. */
1934 risc_address
= *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1935 risc_code_address
= ql1280_board_tbl
[ha
->devnum
].fwcode
;
1936 risc_code_size
= *ql1280_board_tbl
[ha
->devnum
].fwlen
;
1938 for (i
= 0; i
< risc_code_size
; i
++) {
1939 mb
[0] = MBC_WRITE_RAM_WORD
;
1940 mb
[1] = risc_address
+ i
;
1941 mb
[2] = risc_code_address
[i
];
1943 err
= qla1280_mailbox_command(ha
, BIT_0
| BIT_1
| BIT_2
, mb
);
1945 printk(KERN_ERR
"scsi(%li): Failed to load firmware\n",
1954 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
1956 qla1280_load_firmware_dma(struct scsi_qla_host
*ha
)
1958 uint16_t risc_address
, *risc_code_address
, risc_code_size
;
1959 uint16_t mb
[MAILBOX_REGISTER_COUNT
], cnt
;
1960 int err
= 0, num
, i
;
1965 tbuf
= pci_alloc_consistent(ha
->pdev
, 8000, &p_tbuf
);
1970 /* Load RISC code. */
1971 risc_address
= *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1972 risc_code_address
= ql1280_board_tbl
[ha
->devnum
].fwcode
;
1973 risc_code_size
= *ql1280_board_tbl
[ha
->devnum
].fwlen
;
1975 dprintk(1, "%s: DMA RISC code (%i) words\n",
1976 __FUNCTION__
, risc_code_size
);
1979 while (risc_code_size
> 0) {
1980 int warn
__attribute__((unused
)) = 0;
1984 if (cnt
> risc_code_size
)
1985 cnt
= risc_code_size
;
1987 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1989 risc_code_address
, cnt
, num
, risc_address
);
1990 for(i
= 0; i
< cnt
; i
++)
1991 ((uint16_t *)ha
->request_ring
)[i
] =
1992 cpu_to_le16(risc_code_address
[i
]);
1994 mb
[0] = MBC_LOAD_RAM
;
1995 mb
[1] = risc_address
;
1997 mb
[3] = ha
->request_dma
& 0xffff;
1998 mb
[2] = (ha
->request_dma
>> 16) & 0xffff;
1999 mb
[7] = pci_dma_hi32(ha
->request_dma
) & 0xffff;
2000 mb
[6] = pci_dma_hi32(ha
->request_dma
) >> 16;
2001 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
2002 __FUNCTION__
, mb
[0],
2003 (void *)(long)ha
->request_dma
,
2004 mb
[6], mb
[7], mb
[2], mb
[3]);
2005 err
= qla1280_mailbox_command(ha
, BIT_4
| BIT_3
| BIT_2
|
2008 printk(KERN_ERR
"scsi(%li): Failed to load partial "
2009 "segment of f\n", ha
->host_no
);
2014 mb
[0] = MBC_DUMP_RAM
;
2015 mb
[1] = risc_address
;
2017 mb
[3] = p_tbuf
& 0xffff;
2018 mb
[2] = (p_tbuf
>> 16) & 0xffff;
2019 mb
[7] = pci_dma_hi32(p_tbuf
) & 0xffff;
2020 mb
[6] = pci_dma_hi32(p_tbuf
) >> 16;
2022 err
= qla1280_mailbox_command(ha
, BIT_4
| BIT_3
| BIT_2
|
2026 "Failed to dump partial segment of f/w\n");
2029 sp
= (uint8_t *)ha
->request_ring
;
2030 for (i
= 0; i
< (cnt
<< 1); i
++) {
2031 if (tbuf
[i
] != sp
[i
] && warn
++ < 10) {
2032 printk(KERN_ERR
"%s: FW compare error @ "
2033 "byte(0x%x) loop#=%x\n",
2034 __FUNCTION__
, i
, num
);
2035 printk(KERN_ERR
"%s: FWbyte=%x "
2037 __FUNCTION__
, sp
[i
], tbuf
[i
]);
2042 risc_address
+= cnt
;
2043 risc_code_size
= risc_code_size
- cnt
;
2044 risc_code_address
= risc_code_address
+ cnt
;
2050 pci_free_consistent(ha
->pdev
, 8000, tbuf
, p_tbuf
);
2056 qla1280_start_firmware(struct scsi_qla_host
*ha
)
2058 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2061 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
2064 /* Verify checksum of loaded RISC code. */
2065 mb
[0] = MBC_VERIFY_CHECKSUM
;
2066 /* mb[1] = ql12_risc_code_addr01; */
2067 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2068 err
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, mb
);
2070 printk(KERN_ERR
"scsi(%li): Failed checksum\n", ha
->host_no
);
2074 /* Start firmware execution. */
2075 dprintk(1, "%s: start firmware running.\n", __FUNCTION__
);
2076 mb
[0] = MBC_EXECUTE_FIRMWARE
;
2077 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2078 err
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2080 printk(KERN_ERR
"scsi(%li): Failed to start firmware\n",
2088 qla1280_load_firmware(struct scsi_qla_host
*ha
)
2092 /* If firmware needs to be loaded */
2093 if (!qla1280_isp_firmware(ha
)) {
2094 printk(KERN_ERR
"scsi(%li): isp_firmware() failed!\n",
2099 err
= qla1280_chip_diag(ha
);
2103 err
= qla1280_load_firmware_pio(ha
);
2105 err
= qla1280_load_firmware_dma(ha
);
2108 err
= qla1280_start_firmware(ha
);
2117 * ha = adapter block pointer.
2118 * ha->request_ring = request ring virtual address
2119 * ha->response_ring = response ring virtual address
2120 * ha->request_dma = request ring physical address
2121 * ha->response_dma = response ring physical address
2127 qla1280_init_rings(struct scsi_qla_host
*ha
)
2129 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2132 ENTER("qla1280_init_rings");
2134 /* Clear outstanding commands array. */
2135 memset(ha
->outstanding_cmds
, 0,
2136 sizeof(struct srb
*) * MAX_OUTSTANDING_COMMANDS
);
2138 /* Initialize request queue. */
2139 ha
->request_ring_ptr
= ha
->request_ring
;
2140 ha
->req_ring_index
= 0;
2141 ha
->req_q_cnt
= REQUEST_ENTRY_CNT
;
2142 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
2143 mb
[0] = MBC_INIT_REQUEST_QUEUE_A64
;
2144 mb
[1] = REQUEST_ENTRY_CNT
;
2145 mb
[3] = ha
->request_dma
& 0xffff;
2146 mb
[2] = (ha
->request_dma
>> 16) & 0xffff;
2148 mb
[7] = pci_dma_hi32(ha
->request_dma
) & 0xffff;
2149 mb
[6] = pci_dma_hi32(ha
->request_dma
) >> 16;
2150 if (!(status
= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_4
|
2151 BIT_3
| BIT_2
| BIT_1
| BIT_0
,
2153 /* Initialize response queue. */
2154 ha
->response_ring_ptr
= ha
->response_ring
;
2155 ha
->rsp_ring_index
= 0;
2156 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
2157 mb
[0] = MBC_INIT_RESPONSE_QUEUE_A64
;
2158 mb
[1] = RESPONSE_ENTRY_CNT
;
2159 mb
[3] = ha
->response_dma
& 0xffff;
2160 mb
[2] = (ha
->response_dma
>> 16) & 0xffff;
2162 mb
[7] = pci_dma_hi32(ha
->response_dma
) & 0xffff;
2163 mb
[6] = pci_dma_hi32(ha
->response_dma
) >> 16;
2164 status
= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_5
|
2165 BIT_3
| BIT_2
| BIT_1
| BIT_0
,
2170 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
2172 LEAVE("qla1280_init_rings");
2177 qla1280_print_settings(struct nvram
*nv
)
2179 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
2180 nv
->bus
[0].config_1
.initiator_id
);
2181 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
2182 nv
->bus
[1].config_1
.initiator_id
);
2184 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
2185 nv
->bus
[0].bus_reset_delay
);
2186 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
2187 nv
->bus
[1].bus_reset_delay
);
2189 dprintk(1, "qla1280 : retry count[0]=%d\n", nv
->bus
[0].retry_count
);
2190 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv
->bus
[0].retry_delay
);
2191 dprintk(1, "qla1280 : retry count[1]=%d\n", nv
->bus
[1].retry_count
);
2192 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv
->bus
[1].retry_delay
);
2194 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
2195 nv
->bus
[0].config_2
.async_data_setup_time
);
2196 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
2197 nv
->bus
[1].config_2
.async_data_setup_time
);
2199 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
2200 nv
->bus
[0].config_2
.req_ack_active_negation
);
2201 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
2202 nv
->bus
[1].config_2
.req_ack_active_negation
);
2204 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
2205 nv
->bus
[0].config_2
.data_line_active_negation
);
2206 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
2207 nv
->bus
[1].config_2
.data_line_active_negation
);
2209 dprintk(1, "qla1280 : disable loading risc code=%d\n",
2210 nv
->cntr_flags_1
.disable_loading_risc_code
);
2212 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
2213 nv
->cntr_flags_1
.enable_64bit_addressing
);
2215 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
2216 nv
->bus
[0].selection_timeout
);
2217 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
2218 nv
->bus
[1].selection_timeout
);
2220 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
2221 nv
->bus
[0].max_queue_depth
);
2222 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
2223 nv
->bus
[1].max_queue_depth
);
2227 qla1280_set_target_defaults(struct scsi_qla_host
*ha
, int bus
, int target
)
2229 struct nvram
*nv
= &ha
->nvram
;
2231 nv
->bus
[bus
].target
[target
].parameter
.f
.renegotiate_on_error
= 1;
2232 nv
->bus
[bus
].target
[target
].parameter
.f
.auto_request_sense
= 1;
2233 nv
->bus
[bus
].target
[target
].parameter
.f
.tag_queuing
= 1;
2234 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 1;
2235 #if 1 /* Some SCSI Processors do not seem to like this */
2236 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 1;
2238 nv
->bus
[bus
].target
[target
].parameter
.f
.parity_checking
= 1;
2239 nv
->bus
[bus
].target
[target
].parameter
.f
.disconnect_allowed
= 1;
2240 nv
->bus
[bus
].target
[target
].execution_throttle
=
2241 nv
->bus
[bus
].max_queue_depth
- 1;
2243 if (IS_ISP1x160(ha
)) {
2244 nv
->bus
[bus
].target
[target
].flags
.flags1x160
.device_enable
= 1;
2245 nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
= 0x0e;
2246 nv
->bus
[bus
].target
[target
].sync_period
= 9;
2247 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 1;
2248 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_options
= 2;
2249 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_bus_width
= 1;
2251 nv
->bus
[bus
].target
[target
].flags
.flags1x80
.device_enable
= 1;
2252 nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
= 12;
2253 nv
->bus
[bus
].target
[target
].sync_period
= 10;
2258 qla1280_set_defaults(struct scsi_qla_host
*ha
)
2260 struct nvram
*nv
= &ha
->nvram
;
2263 dprintk(1, "Using defaults for NVRAM: \n");
2264 memset(nv
, 0, sizeof(struct nvram
));
2266 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2267 nv
->firmware_feature
.f
.enable_fast_posting
= 1;
2268 nv
->firmware_feature
.f
.disable_synchronous_backoff
= 1;
2269 nv
->termination
.f
.scsi_bus_0_control
= 3;
2270 nv
->termination
.f
.scsi_bus_1_control
= 3;
2271 nv
->termination
.f
.auto_term_support
= 1;
2274 * Set default FIFO magic - What appropriate values would be here
2275 * is unknown. This is what I have found testing with 12160s.
2277 * Now, I would love the magic decoder ring for this one, the
2278 * header file provided by QLogic seems to be bogus or incomplete
2281 nv
->isp_config
.c
= ISP_CFG1_BENAB
|ISP_CFG1_F128
;
2282 if (IS_ISP1x160(ha
))
2283 nv
->isp_parameter
= 0x01; /* fast memory enable */
2285 for (bus
= 0; bus
< MAX_BUSES
; bus
++) {
2286 nv
->bus
[bus
].config_1
.initiator_id
= 7;
2287 nv
->bus
[bus
].config_2
.req_ack_active_negation
= 1;
2288 nv
->bus
[bus
].config_2
.data_line_active_negation
= 1;
2289 nv
->bus
[bus
].selection_timeout
= 250;
2290 nv
->bus
[bus
].max_queue_depth
= 256;
2292 if (IS_ISP1040(ha
)) {
2293 nv
->bus
[bus
].bus_reset_delay
= 3;
2294 nv
->bus
[bus
].config_2
.async_data_setup_time
= 6;
2295 nv
->bus
[bus
].retry_delay
= 1;
2297 nv
->bus
[bus
].bus_reset_delay
= 5;
2298 nv
->bus
[bus
].config_2
.async_data_setup_time
= 8;
2301 for (target
= 0; target
< MAX_TARGETS
; target
++)
2302 qla1280_set_target_defaults(ha
, bus
, target
);
2307 qla1280_config_target(struct scsi_qla_host
*ha
, int bus
, int target
)
2309 struct nvram
*nv
= &ha
->nvram
;
2310 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2313 /* Set Target Parameters. */
2314 mb
[0] = MBC_SET_TARGET_PARAMETERS
;
2315 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
2319 * Do not enable wide, sync, and ppr for the initial
2320 * INQUIRY run. We enable this later if we determine
2321 * the target actually supports it.
2323 nv
->bus
[bus
].target
[target
].parameter
.f
.
2324 auto_request_sense
= 1;
2325 nv
->bus
[bus
].target
[target
].parameter
.f
.
2326 stop_queue_on_check
= 0;
2328 if (IS_ISP1x160(ha
))
2329 nv
->bus
[bus
].target
[target
].ppr_1x160
.
2330 flags
.enable_ppr
= 0;
2333 * No sync, wide, etc. while probing
2335 mb
[2] = (nv
->bus
[bus
].target
[target
].parameter
.c
<< 8) &
2336 ~(TP_SYNC
/*| TP_WIDE | TP_PPR*/);
2338 if (IS_ISP1x160(ha
))
2339 mb
[3] = nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
<< 8;
2341 mb
[3] = nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
<< 8;
2342 mb
[3] |= nv
->bus
[bus
].target
[target
].sync_period
;
2344 status
= qla1280_mailbox_command(ha
, BIT_3
| BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2346 /* Save Tag queuing enable flag. */
2347 mb
[0] = BIT_0
<< target
;
2348 if (nv
->bus
[bus
].target
[target
].parameter
.f
.tag_queuing
)
2349 ha
->bus_settings
[bus
].qtag_enables
|= mb
[0];
2351 /* Save Device enable flag. */
2352 if (IS_ISP1x160(ha
)) {
2353 if (nv
->bus
[bus
].target
[target
].flags
.flags1x160
.device_enable
)
2354 ha
->bus_settings
[bus
].device_enables
|= mb
[0];
2355 ha
->bus_settings
[bus
].lun_disables
|= 0;
2357 if (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.device_enable
)
2358 ha
->bus_settings
[bus
].device_enables
|= mb
[0];
2359 /* Save LUN disable flag. */
2360 if (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.lun_disable
)
2361 ha
->bus_settings
[bus
].lun_disables
|= mb
[0];
2364 /* Set Device Queue Parameters. */
2365 for (lun
= 0; lun
< MAX_LUNS
; lun
++) {
2366 mb
[0] = MBC_SET_DEVICE_QUEUE
;
2367 mb
[1] = (uint16_t)(bus
? target
| BIT_7
: target
);
2368 mb
[1] = mb
[1] << 8 | lun
;
2369 mb
[2] = nv
->bus
[bus
].max_queue_depth
;
2370 mb
[3] = nv
->bus
[bus
].target
[target
].execution_throttle
;
2371 status
|= qla1280_mailbox_command(ha
, 0x0f, &mb
[0]);
2378 qla1280_config_bus(struct scsi_qla_host
*ha
, int bus
)
2380 struct nvram
*nv
= &ha
->nvram
;
2381 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2384 /* SCSI Reset Disable. */
2385 ha
->bus_settings
[bus
].disable_scsi_reset
=
2386 nv
->bus
[bus
].config_1
.scsi_reset_disable
;
2389 ha
->bus_settings
[bus
].id
= nv
->bus
[bus
].config_1
.initiator_id
;
2390 mb
[0] = MBC_SET_INITIATOR_ID
;
2391 mb
[1] = bus
? ha
->bus_settings
[bus
].id
| BIT_7
:
2392 ha
->bus_settings
[bus
].id
;
2393 status
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2396 ha
->bus_settings
[bus
].bus_reset_delay
=
2397 nv
->bus
[bus
].bus_reset_delay
;
2399 /* Command queue depth per device. */
2400 ha
->bus_settings
[bus
].hiwat
= nv
->bus
[bus
].max_queue_depth
- 1;
2402 /* Set target parameters. */
2403 for (target
= 0; target
< MAX_TARGETS
; target
++)
2404 status
|= qla1280_config_target(ha
, bus
, target
);
2410 qla1280_nvram_config(struct scsi_qla_host
*ha
)
2412 struct device_reg __iomem
*reg
= ha
->iobase
;
2413 struct nvram
*nv
= &ha
->nvram
;
2414 int bus
, target
, status
= 0;
2415 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2418 ENTER("qla1280_nvram_config");
2420 if (ha
->nvram_valid
) {
2421 /* Always force AUTO sense for LINUX SCSI */
2422 for (bus
= 0; bus
< MAX_BUSES
; bus
++)
2423 for (target
= 0; target
< MAX_TARGETS
; target
++) {
2424 nv
->bus
[bus
].target
[target
].parameter
.f
.
2425 auto_request_sense
= 1;
2428 qla1280_set_defaults(ha
);
2431 qla1280_print_settings(nv
);
2433 /* Disable RISC load of firmware. */
2434 ha
->flags
.disable_risc_code_load
=
2435 nv
->cntr_flags_1
.disable_loading_risc_code
;
2437 if (IS_ISP1040(ha
)) {
2438 uint16_t hwrev
, cfg1
, cdma_conf
, ddma_conf
;
2440 hwrev
= RD_REG_WORD(®
->cfg_0
) & ISP_CFG0_HWMSK
;
2442 cfg1
= RD_REG_WORD(®
->cfg_1
);
2443 cdma_conf
= RD_REG_WORD(®
->cdma_cfg
);
2444 ddma_conf
= RD_REG_WORD(®
->ddma_cfg
);
2446 /* Busted fifo, says mjacob. */
2447 if (hwrev
== ISP_CFG0_1040A
)
2448 WRT_REG_WORD(®
->cfg_1
, cfg1
| ISP_CFG1_F64
);
2450 WRT_REG_WORD(®
->cfg_1
, cfg1
| ISP_CFG1_F64
| ISP_CFG1_BENAB
);
2452 WRT_REG_WORD(®
->cdma_cfg
, cdma_conf
| CDMA_CONF_BENAB
);
2453 WRT_REG_WORD(®
->ddma_cfg
, cdma_conf
| DDMA_CONF_BENAB
);
2455 /* Set ISP hardware DMA burst */
2456 mb
[0] = nv
->isp_config
.c
;
2457 /* Enable DMA arbitration on dual channel controllers */
2460 WRT_REG_WORD(®
->cfg_1
, mb
[0]);
2462 /* Set SCSI termination. */
2463 WRT_REG_WORD(®
->gpio_enable
, (BIT_3
+ BIT_2
+ BIT_1
+ BIT_0
));
2464 mb
[0] = nv
->termination
.c
& (BIT_3
+ BIT_2
+ BIT_1
+ BIT_0
);
2465 WRT_REG_WORD(®
->gpio_data
, mb
[0]);
2468 /* ISP parameter word. */
2469 mb
[0] = MBC_SET_SYSTEM_PARAMETER
;
2470 mb
[1] = nv
->isp_parameter
;
2471 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2473 if (IS_ISP1x40(ha
)) {
2474 /* clock rate - for qla1240 and older, only */
2475 mb
[0] = MBC_SET_CLOCK_RATE
;
2477 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, mb
);
2480 /* Firmware feature word. */
2481 mb
[0] = MBC_SET_FIRMWARE_FEATURES
;
2482 mask
= BIT_5
| BIT_1
| BIT_0
;
2483 mb
[1] = le16_to_cpu(nv
->firmware_feature
.w
) & (mask
);
2484 #if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2485 if (ia64_platform_is("sn2")) {
2486 printk(KERN_INFO
"scsi(%li): Enabling SN2 PCI DMA "
2487 "workaround\n", ha
->host_no
);
2491 status
|= qla1280_mailbox_command(ha
, mask
, &mb
[0]);
2493 /* Retry count and delay. */
2494 mb
[0] = MBC_SET_RETRY_COUNT
;
2495 mb
[1] = nv
->bus
[0].retry_count
;
2496 mb
[2] = nv
->bus
[0].retry_delay
;
2497 mb
[6] = nv
->bus
[1].retry_count
;
2498 mb
[7] = nv
->bus
[1].retry_delay
;
2499 status
|= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_2
|
2500 BIT_1
| BIT_0
, &mb
[0]);
2502 /* ASYNC data setup time. */
2503 mb
[0] = MBC_SET_ASYNC_DATA_SETUP
;
2504 mb
[1] = nv
->bus
[0].config_2
.async_data_setup_time
;
2505 mb
[2] = nv
->bus
[1].config_2
.async_data_setup_time
;
2506 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2508 /* Active negation states. */
2509 mb
[0] = MBC_SET_ACTIVE_NEGATION
;
2511 if (nv
->bus
[0].config_2
.req_ack_active_negation
)
2513 if (nv
->bus
[0].config_2
.data_line_active_negation
)
2516 if (nv
->bus
[1].config_2
.req_ack_active_negation
)
2518 if (nv
->bus
[1].config_2
.data_line_active_negation
)
2520 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2522 mb
[0] = MBC_SET_DATA_OVERRUN_RECOVERY
;
2523 mb
[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2524 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2527 mb
[0] = MBC_SET_PCI_CONTROL
;
2528 mb
[1] = 2; /* Data DMA Channel Burst Enable */
2529 mb
[2] = 2; /* Command DMA Channel Burst Enable */
2530 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2532 mb
[0] = MBC_SET_TAG_AGE_LIMIT
;
2534 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2536 /* Selection timeout. */
2537 mb
[0] = MBC_SET_SELECTION_TIMEOUT
;
2538 mb
[1] = nv
->bus
[0].selection_timeout
;
2539 mb
[2] = nv
->bus
[1].selection_timeout
;
2540 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2542 for (bus
= 0; bus
< ha
->ports
; bus
++)
2543 status
|= qla1280_config_bus(ha
, bus
);
2546 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2548 LEAVE("qla1280_nvram_config");
2553 * Get NVRAM data word
2554 * Calculates word position in NVRAM and calls request routine to
2555 * get the word from NVRAM.
2558 * ha = adapter block pointer.
2559 * address = NVRAM word address.
2565 qla1280_get_nvram_word(struct scsi_qla_host
*ha
, uint32_t address
)
2570 nv_cmd
= address
<< 16;
2571 nv_cmd
|= NV_READ_OP
;
2573 data
= le16_to_cpu(qla1280_nvram_request(ha
, nv_cmd
));
2575 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2583 * Sends read command to NVRAM and gets data from NVRAM.
2586 * ha = adapter block pointer.
2587 * nv_cmd = Bit 26 = start bit
2588 * Bit 25, 24 = opcode
2589 * Bit 23-16 = address
2590 * Bit 15-0 = write data
2596 qla1280_nvram_request(struct scsi_qla_host
*ha
, uint32_t nv_cmd
)
2598 struct device_reg __iomem
*reg
= ha
->iobase
;
2603 /* Send command to NVRAM. */
2606 for (cnt
= 0; cnt
< 11; cnt
++) {
2607 if (nv_cmd
& BIT_31
)
2608 qla1280_nv_write(ha
, NV_DATA_OUT
);
2610 qla1280_nv_write(ha
, 0);
2614 /* Read data from NVRAM. */
2616 for (cnt
= 0; cnt
< 16; cnt
++) {
2617 WRT_REG_WORD(®
->nvram
, (NV_SELECT
| NV_CLOCK
));
2618 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2621 reg_data
= RD_REG_WORD(®
->nvram
);
2622 if (reg_data
& NV_DATA_IN
)
2624 WRT_REG_WORD(®
->nvram
, NV_SELECT
);
2625 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2629 /* Deselect chip. */
2631 WRT_REG_WORD(®
->nvram
, NV_DESELECT
);
2632 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2639 qla1280_nv_write(struct scsi_qla_host
*ha
, uint16_t data
)
2641 struct device_reg __iomem
*reg
= ha
->iobase
;
2643 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
);
2644 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2646 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
| NV_CLOCK
);
2647 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2649 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
);
2650 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2656 * Issue mailbox command and waits for completion.
2659 * ha = adapter block pointer.
2660 * mr = mailbox registers to load.
2661 * mb = data pointer for mailbox registers.
2664 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2670 qla1280_mailbox_command(struct scsi_qla_host
*ha
, uint8_t mr
, uint16_t *mb
)
2672 struct device_reg __iomem
*reg
= ha
->iobase
;
2678 uint16_t *optr
, *iptr
;
2679 uint16_t __iomem
*mptr
;
2681 DECLARE_COMPLETION(wait
);
2682 struct timer_list timer
;
2684 ENTER("qla1280_mailbox_command");
2686 if (ha
->mailbox_wait
) {
2687 printk(KERN_ERR
"Warning mailbox wait already in use!\n");
2689 ha
->mailbox_wait
= &wait
;
2692 * We really should start out by verifying that the mailbox is
2693 * available before starting sending the command data
2695 /* Load mailbox registers. */
2696 mptr
= (uint16_t __iomem
*) ®
->mailbox0
;
2698 for (cnt
= 0; cnt
< MAILBOX_REGISTER_COUNT
; cnt
++) {
2700 WRT_REG_WORD(mptr
, (*iptr
));
2708 /* Issue set host interrupt command. */
2710 /* set up a timer just in case we're really jammed */
2712 timer
.expires
= jiffies
+ 20*HZ
;
2713 timer
.data
= (unsigned long)ha
;
2714 timer
.function
= qla1280_mailbox_timeout
;
2717 spin_unlock_irq(HOST_LOCK
);
2718 WRT_REG_WORD(®
->host_cmd
, HC_SET_HOST_INT
);
2719 data
= qla1280_debounce_register(®
->istatus
);
2721 wait_for_completion(&wait
);
2722 del_timer_sync(&timer
);
2724 spin_lock_irq(HOST_LOCK
);
2726 ha
->mailbox_wait
= NULL
;
2728 /* Check for mailbox command timeout. */
2729 if (ha
->mailbox_out
[0] != MBS_CMD_CMP
) {
2730 printk(KERN_WARNING
"qla1280_mailbox_command: Command failed, "
2731 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2733 mb
[0], ha
->mailbox_out
[0], RD_REG_WORD(®
->istatus
));
2734 printk(KERN_WARNING
"m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2735 RD_REG_WORD(®
->mailbox0
), RD_REG_WORD(®
->mailbox1
),
2736 RD_REG_WORD(®
->mailbox2
), RD_REG_WORD(®
->mailbox3
));
2737 printk(KERN_WARNING
"m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2738 RD_REG_WORD(®
->mailbox4
), RD_REG_WORD(®
->mailbox5
),
2739 RD_REG_WORD(®
->mailbox6
), RD_REG_WORD(®
->mailbox7
));
2743 /* Load return mailbox registers. */
2745 iptr
= (uint16_t *) &ha
->mailbox_out
[0];
2746 mr
= MAILBOX_REGISTER_COUNT
;
2747 memcpy(optr
, iptr
, MAILBOX_REGISTER_COUNT
* sizeof(uint16_t));
2750 /* Go check for any response interrupts pending. */
2751 qla1280_isr(ha
, &done_q
);
2754 if (ha
->flags
.reset_marker
)
2755 qla1280_rst_aen(ha
);
2758 if (!list_empty(&done_q
))
2759 qla1280_done(ha
, &done_q
);
2763 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2764 "0x%x ****\n", mb
[0]);
2766 LEAVE("qla1280_mailbox_command");
2772 * Polls ISP for interrupts.
2775 * ha = adapter block pointer.
2778 qla1280_poll(struct scsi_qla_host
*ha
)
2780 struct device_reg __iomem
*reg
= ha
->iobase
;
2784 /* ENTER("qla1280_poll"); */
2786 /* Check for pending interrupts. */
2787 data
= RD_REG_WORD(®
->istatus
);
2788 if (data
& RISC_INT
)
2789 qla1280_isr(ha
, &done_q
);
2791 if (!ha
->mailbox_wait
) {
2792 if (ha
->flags
.reset_marker
)
2793 qla1280_rst_aen(ha
);
2796 if (!list_empty(&done_q
))
2799 /* LEAVE("qla1280_poll"); */
2804 * Issue SCSI bus reset.
2807 * ha = adapter block pointer.
2808 * bus = SCSI bus number.
2814 qla1280_bus_reset(struct scsi_qla_host
*ha
, int bus
)
2816 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2817 uint16_t reset_delay
;
2820 dprintk(3, "qla1280_bus_reset: entered\n");
2822 if (qla1280_verbose
)
2823 printk(KERN_INFO
"scsi(%li:%i): Resetting SCSI BUS\n",
2826 reset_delay
= ha
->bus_settings
[bus
].bus_reset_delay
;
2827 mb
[0] = MBC_BUS_RESET
;
2828 mb
[1] = reset_delay
;
2829 mb
[2] = (uint16_t) bus
;
2830 status
= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2833 if (ha
->bus_settings
[bus
].failed_reset_count
> 2)
2834 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
2835 ha
->bus_settings
[bus
].failed_reset_count
++;
2837 spin_unlock_irq(HOST_LOCK
);
2838 schedule_timeout(reset_delay
* HZ
);
2839 spin_lock_irq(HOST_LOCK
);
2841 ha
->bus_settings
[bus
].scsi_bus_dead
= 0;
2842 ha
->bus_settings
[bus
].failed_reset_count
= 0;
2843 ha
->bus_settings
[bus
].reset_marker
= 0;
2844 /* Issue marker command. */
2845 qla1280_marker(ha
, bus
, 0, 0, MK_SYNC_ALL
);
2849 * We should probably call qla1280_set_target_parameters()
2850 * here as well for all devices on the bus.
2854 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2856 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2862 * qla1280_device_reset
2863 * Issue bus device reset message to the target.
2866 * ha = adapter block pointer.
2867 * bus = SCSI BUS number.
2874 qla1280_device_reset(struct scsi_qla_host
*ha
, int bus
, int target
)
2876 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2879 ENTER("qla1280_device_reset");
2881 mb
[0] = MBC_ABORT_TARGET
;
2882 mb
[1] = (bus
? (target
| BIT_7
) : target
) << 8;
2884 status
= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2886 /* Issue marker command. */
2887 qla1280_marker(ha
, bus
, target
, 0, MK_SYNC_ID
);
2890 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2892 LEAVE("qla1280_device_reset");
2897 * qla1280_abort_device
2898 * Issue an abort message to the device
2901 * ha = adapter block pointer.
2910 qla1280_abort_device(struct scsi_qla_host
*ha
, int bus
, int target
, int lun
)
2912 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2915 ENTER("qla1280_abort_device");
2917 mb
[0] = MBC_ABORT_DEVICE
;
2918 mb
[1] = (bus
? target
| BIT_7
: target
) << 8 | lun
;
2919 status
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2921 /* Issue marker command. */
2922 qla1280_marker(ha
, bus
, target
, lun
, MK_SYNC_ID_LUN
);
2925 dprintk(2, "qla1280_abort_device: **** FAILED ****\n");
2927 LEAVE("qla1280_abort_device");
2932 * qla1280_abort_command
2933 * Abort command aborts a specified IOCB.
2936 * ha = adapter block pointer.
2937 * sp = SB structure pointer.
2943 qla1280_abort_command(struct scsi_qla_host
*ha
, struct srb
* sp
, int handle
)
2945 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2946 unsigned int bus
, target
, lun
;
2949 ENTER("qla1280_abort_command");
2951 bus
= SCSI_BUS_32(sp
->cmd
);
2952 target
= SCSI_TCN_32(sp
->cmd
);
2953 lun
= SCSI_LUN_32(sp
->cmd
);
2955 sp
->flags
|= SRB_ABORT_PENDING
;
2957 mb
[0] = MBC_ABORT_COMMAND
;
2958 mb
[1] = (bus
? target
| BIT_7
: target
) << 8 | lun
;
2959 mb
[2] = handle
>> 16;
2960 mb
[3] = handle
& 0xffff;
2961 status
= qla1280_mailbox_command(ha
, 0x0f, &mb
[0]);
2964 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2965 sp
->flags
&= ~SRB_ABORT_PENDING
;
2969 LEAVE("qla1280_abort_command");
2974 * qla1280_reset_adapter
2978 * ha = adapter block pointer.
2981 qla1280_reset_adapter(struct scsi_qla_host
*ha
)
2983 struct device_reg __iomem
*reg
= ha
->iobase
;
2985 ENTER("qla1280_reset_adapter");
2987 /* Disable ISP chip */
2988 ha
->flags
.online
= 0;
2989 WRT_REG_WORD(®
->ictrl
, ISP_RESET
);
2990 WRT_REG_WORD(®
->host_cmd
,
2991 HC_RESET_RISC
| HC_RELEASE_RISC
| HC_DISABLE_BIOS
);
2992 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2994 LEAVE("qla1280_reset_adapter");
2998 * Issue marker command.
2999 * Function issues marker IOCB.
3002 * ha = adapter block pointer.
3003 * bus = SCSI BUS number
3006 * type = marker modifier
3009 qla1280_marker(struct scsi_qla_host
*ha
, int bus
, int id
, int lun
, u8 type
)
3011 struct mrk_entry
*pkt
;
3013 ENTER("qla1280_marker");
3015 /* Get request packet. */
3016 if ((pkt
= (struct mrk_entry
*) qla1280_req_pkt(ha
))) {
3017 pkt
->entry_type
= MARKER_TYPE
;
3018 pkt
->lun
= (uint8_t) lun
;
3019 pkt
->target
= (uint8_t) (bus
? (id
| BIT_7
) : id
);
3020 pkt
->modifier
= type
;
3021 pkt
->entry_status
= 0;
3023 /* Issue command to ISP */
3024 qla1280_isp_cmd(ha
);
3027 LEAVE("qla1280_marker");
3032 * qla1280_64bit_start_scsi
3033 * The start SCSI is responsible for building request packets on
3034 * request ring and modifying ISP input pointer.
3037 * ha = adapter block pointer.
3038 * sp = SB structure pointer.
3041 * 0 = success, was able to issue command.
3043 #ifdef QLA_64BIT_PTR
3045 qla1280_64bit_start_scsi(struct scsi_qla_host
*ha
, struct srb
* sp
)
3047 struct device_reg __iomem
*reg
= ha
->iobase
;
3048 struct scsi_cmnd
*cmd
= sp
->cmd
;
3049 cmd_a64_entry_t
*pkt
;
3050 struct scatterlist
*sg
= NULL
;
3052 dma_addr_t dma_handle
;
3059 ENTER("qla1280_64bit_start_scsi:");
3061 /* Calculate number of entries and segments required. */
3064 sg
= (struct scatterlist
*) cmd
->request_buffer
;
3065 seg_cnt
= pci_map_sg(ha
->pdev
, sg
, cmd
->use_sg
,
3066 cmd
->sc_data_direction
);
3069 req_cnt
+= (seg_cnt
- 2) / 5;
3070 if ((seg_cnt
- 2) % 5)
3073 } else if (cmd
->request_bufflen
) { /* If data transfer. */
3079 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3080 /* Calculate number of free request entries. */
3081 cnt
= RD_REG_WORD(®
->mailbox4
);
3082 if (ha
->req_ring_index
< cnt
)
3083 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3086 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3089 /* If room for request in request ring. */
3090 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3092 dprintk(2, "qla1280_64bit_start_scsi: in-ptr=0x%x req_q_cnt="
3093 "0x%xreq_cnt=0x%x", ha
->req_ring_index
, ha
->req_q_cnt
,
3098 /* Check for room in outstanding command list. */
3099 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
&&
3100 ha
->outstanding_cmds
[cnt
] != 0; cnt
++);
3102 if (cnt
>= MAX_OUTSTANDING_COMMANDS
) {
3104 dprintk(2, "qla1280_64bit_start_scsi: NO ROOM IN "
3105 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha
->req_q_cnt
);
3109 ha
->outstanding_cmds
[cnt
] = sp
;
3110 ha
->req_q_cnt
-= req_cnt
;
3111 CMD_HANDLE(sp
->cmd
) = (unsigned char *)(unsigned long)(cnt
+ 1);
3113 dprintk(2, "64bit_start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd
, sp
,
3114 cmd
->cmnd
[0], (long)CMD_HANDLE(sp
->cmd
));
3115 dprintk(2, " bus %i, target %i, lun %i\n",
3116 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3117 qla1280_dump_buffer(2, cmd
->cmnd
, MAX_COMMAND_SIZE
);
3120 * Build command packet.
3122 pkt
= (cmd_a64_entry_t
*) ha
->request_ring_ptr
;
3124 pkt
->entry_type
= COMMAND_A64_TYPE
;
3125 pkt
->entry_count
= (uint8_t) req_cnt
;
3126 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3127 pkt
->entry_status
= 0;
3128 pkt
->handle
= cpu_to_le32(cnt
);
3130 /* Zero out remaining portion of packet. */
3131 memset(((char *)pkt
+ 8), 0, (REQUEST_ENTRY_SIZE
- 8));
3133 /* Set ISP command timeout. */
3134 pkt
->timeout
= cpu_to_le16(30);
3136 /* Set device target ID and LUN */
3137 pkt
->lun
= SCSI_LUN_32(cmd
);
3138 pkt
->target
= SCSI_BUS_32(cmd
) ?
3139 (SCSI_TCN_32(cmd
) | BIT_7
) : SCSI_TCN_32(cmd
);
3141 /* Enable simple tag queuing if device supports it. */
3142 if (DEV_SIMPLE_TAGS(cmd
->device
))
3143 pkt
->control_flags
|= cpu_to_le16(BIT_3
);
3145 /* Load SCSI command packet. */
3146 pkt
->cdb_len
= cpu_to_le16(CMD_CDBLEN(cmd
));
3147 memcpy(pkt
->scsi_cdb
, &(CMD_CDBP(cmd
)), CMD_CDBLEN(cmd
));
3148 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3150 /* Set transfer direction. */
3151 dir
= qla1280_data_direction(cmd
);
3152 pkt
->control_flags
|= cpu_to_le16(dir
);
3154 /* Set total data segment count. */
3155 pkt
->dseg_count
= cpu_to_le16(seg_cnt
);
3158 * Load data segments.
3160 if (seg_cnt
) { /* If data transfer. */
3161 /* Setup packet address segment pointer. */
3162 dword_ptr
= (u32
*)&pkt
->dseg_0_address
;
3164 if (cmd
->use_sg
) { /* If scatter gather */
3165 /* Load command entry data segments. */
3166 for (cnt
= 0; cnt
< 2 && seg_cnt
; cnt
++, seg_cnt
--) {
3167 dma_handle
= sg_dma_address(sg
);
3168 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3169 if (ha
->flags
.use_pci_vchannel
)
3170 sn_pci_set_vchan(ha
->pdev
,
3171 (unsigned long *)&dma_handle
,
3175 cpu_to_le32(pci_dma_lo32(dma_handle
));
3177 cpu_to_le32(pci_dma_hi32(dma_handle
));
3178 *dword_ptr
++ = cpu_to_le32(sg_dma_len(sg
));
3180 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
3181 cpu_to_le32(pci_dma_hi32(dma_handle
)),
3182 cpu_to_le32(pci_dma_lo32(dma_handle
)),
3183 cpu_to_le32(sg_dma_len(sg
)));
3185 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
3186 "command packet data - b %i, t %i, l %i \n",
3187 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
),
3189 qla1280_dump_buffer(5, (char *)pkt
,
3190 REQUEST_ENTRY_SIZE
);
3193 * Build continuation packets.
3195 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
3196 "remains\n", seg_cnt
);
3198 while (seg_cnt
> 0) {
3199 /* Adjust ring index. */
3200 ha
->req_ring_index
++;
3201 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3202 ha
->req_ring_index
= 0;
3203 ha
->request_ring_ptr
=
3206 ha
->request_ring_ptr
++;
3208 pkt
= (cmd_a64_entry_t
*)ha
->request_ring_ptr
;
3210 /* Zero out packet. */
3211 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3213 /* Load packet defaults. */
3214 ((struct cont_a64_entry
*) pkt
)->entry_type
=
3216 ((struct cont_a64_entry
*) pkt
)->entry_count
= 1;
3217 ((struct cont_a64_entry
*) pkt
)->sys_define
=
3218 (uint8_t)ha
->req_ring_index
;
3219 /* Setup packet address segment pointer. */
3221 (u32
*)&((struct cont_a64_entry
*) pkt
)->dseg_0_address
;
3223 /* Load continuation entry data segments. */
3224 for (cnt
= 0; cnt
< 5 && seg_cnt
;
3226 dma_handle
= sg_dma_address(sg
);
3227 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3228 if (ha
->flags
.use_pci_vchannel
)
3229 sn_pci_set_vchan(ha
->pdev
,
3230 (unsigned long *)&dma_handle
,
3234 cpu_to_le32(pci_dma_lo32(dma_handle
));
3236 cpu_to_le32(pci_dma_hi32(dma_handle
));
3238 cpu_to_le32(sg_dma_len(sg
));
3239 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
3240 cpu_to_le32(pci_dma_hi32(dma_handle
)),
3241 cpu_to_le32(pci_dma_lo32(dma_handle
)),
3242 cpu_to_le32(sg_dma_len(sg
)));
3245 dprintk(5, "qla1280_64bit_start_scsi: "
3246 "continuation packet data - b %i, t "
3247 "%i, l %i \n", SCSI_BUS_32(cmd
),
3248 SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3249 qla1280_dump_buffer(5, (char *)pkt
,
3250 REQUEST_ENTRY_SIZE
);
3252 } else { /* No scatter gather data transfer */
3253 dma_handle
= pci_map_single(ha
->pdev
,
3254 cmd
->request_buffer
,
3255 cmd
->request_bufflen
,
3256 cmd
->sc_data_direction
);
3258 sp
->saved_dma_handle
= dma_handle
;
3259 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3260 if (ha
->flags
.use_pci_vchannel
)
3261 sn_pci_set_vchan(ha
->pdev
,
3262 (unsigned long *)&dma_handle
,
3265 *dword_ptr
++ = cpu_to_le32(pci_dma_lo32(dma_handle
));
3266 *dword_ptr
++ = cpu_to_le32(pci_dma_hi32(dma_handle
));
3267 *dword_ptr
= cpu_to_le32(cmd
->request_bufflen
);
3269 dprintk(5, "qla1280_64bit_start_scsi: No scatter/"
3270 "gather command packet data - b %i, t %i, "
3271 "l %i \n", SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
),
3273 qla1280_dump_buffer(5, (char *)pkt
,
3274 REQUEST_ENTRY_SIZE
);
3276 } else { /* No data transfer */
3277 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
3278 "packet data - b %i, t %i, l %i \n",
3279 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3280 qla1280_dump_buffer(5, (char *)pkt
, REQUEST_ENTRY_SIZE
);
3282 /* Adjust ring index. */
3283 ha
->req_ring_index
++;
3284 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3285 ha
->req_ring_index
= 0;
3286 ha
->request_ring_ptr
= ha
->request_ring
;
3288 ha
->request_ring_ptr
++;
3290 /* Set chip new ring index. */
3292 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3293 sp
->flags
|= SRB_SENT
;
3295 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3296 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3301 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3303 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3307 #else /* !QLA_64BIT_PTR */
3310 * qla1280_32bit_start_scsi
3311 * The start SCSI is responsible for building request packets on
3312 * request ring and modifying ISP input pointer.
3314 * The Qlogic firmware interface allows every queue slot to have a SCSI
3315 * command and up to 4 scatter/gather (SG) entries. If we need more
3316 * than 4 SG entries, then continuation entries are used that can
3317 * hold another 7 entries each. The start routine determines if there
3318 * is eought empty slots then build the combination of requests to
3319 * fulfill the OS request.
3322 * ha = adapter block pointer.
3323 * sp = SCSI Request Block structure pointer.
3326 * 0 = success, was able to issue command.
3329 qla1280_32bit_start_scsi(struct scsi_qla_host
*ha
, struct srb
* sp
)
3331 struct device_reg __iomem
*reg
= ha
->iobase
;
3332 struct scsi_cmnd
*cmd
= sp
->cmd
;
3333 struct cmd_entry
*pkt
;
3334 struct scatterlist
*sg
= NULL
;
3335 uint32_t *dword_ptr
;
3340 dma_addr_t dma_handle
;
3343 ENTER("qla1280_32bit_start_scsi");
3345 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd
, sp
,
3348 /* Calculate number of entries and segments required. */
3352 * We must build an SG list in adapter format, as the kernel's
3353 * SG list cannot be used directly because of data field size
3354 * (__alpha__) differences and the kernel SG list uses virtual
3355 * addresses where we need physical addresses.
3357 sg
= (struct scatterlist
*) cmd
->request_buffer
;
3358 seg_cnt
= pci_map_sg(ha
->pdev
, sg
, cmd
->use_sg
,
3359 cmd
->sc_data_direction
);
3362 * if greater than four sg entries then we need to allocate
3363 * continuation entries
3366 req_cnt
+= (seg_cnt
- 4) / 7;
3367 if ((seg_cnt
- 4) % 7)
3370 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3371 cmd
, seg_cnt
, req_cnt
);
3372 } else if (cmd
->request_bufflen
) { /* If data transfer. */
3373 dprintk(3, "No S/G transfer t=%x cmd=%p len=%x CDB=%x\n",
3374 SCSI_TCN_32(cmd
), cmd
, cmd
->request_bufflen
,
3378 /* dprintk(1, "No data transfer \n"); */
3382 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3383 /* Calculate number of free request entries. */
3384 cnt
= RD_REG_WORD(®
->mailbox4
);
3385 if (ha
->req_ring_index
< cnt
)
3386 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3389 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3392 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3393 ha
->req_q_cnt
, seg_cnt
);
3394 /* If room for request in request ring. */
3395 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3397 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3398 "req_q_cnt=0x%x, req_cnt=0x%x", ha
->req_ring_index
,
3399 ha
->req_q_cnt
, req_cnt
);
3403 /* Check for empty slot in outstanding command list. */
3404 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
&&
3405 (ha
->outstanding_cmds
[cnt
] != 0); cnt
++) ;
3407 if (cnt
>= MAX_OUTSTANDING_COMMANDS
) {
3409 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3410 "ARRAY, req_q_cnt=0x%x\n", ha
->req_q_cnt
);
3414 CMD_HANDLE(sp
->cmd
) = (unsigned char *) (unsigned long)(cnt
+ 1);
3415 ha
->outstanding_cmds
[cnt
] = sp
;
3416 ha
->req_q_cnt
-= req_cnt
;
3419 * Build command packet.
3421 pkt
= (struct cmd_entry
*) ha
->request_ring_ptr
;
3423 pkt
->entry_type
= COMMAND_TYPE
;
3424 pkt
->entry_count
= (uint8_t) req_cnt
;
3425 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3426 pkt
->entry_status
= 0;
3427 pkt
->handle
= cpu_to_le32(cnt
);
3429 /* Zero out remaining portion of packet. */
3430 memset(((char *)pkt
+ 8), 0, (REQUEST_ENTRY_SIZE
- 8));
3432 /* Set ISP command timeout. */
3433 pkt
->timeout
= cpu_to_le16(30);
3435 /* Set device target ID and LUN */
3436 pkt
->lun
= SCSI_LUN_32(cmd
);
3437 pkt
->target
= SCSI_BUS_32(cmd
) ?
3438 (SCSI_TCN_32(cmd
) | BIT_7
) : SCSI_TCN_32(cmd
);
3440 /* Enable simple tag queuing if device supports it. */
3441 if (DEV_SIMPLE_TAGS(cmd
->device
))
3442 pkt
->control_flags
|= cpu_to_le16(BIT_3
);
3444 /* Load SCSI command packet. */
3445 pkt
->cdb_len
= cpu_to_le16(CMD_CDBLEN(cmd
));
3446 memcpy(pkt
->scsi_cdb
, &(CMD_CDBP(cmd
)), CMD_CDBLEN(cmd
));
3448 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3449 /* Set transfer direction. */
3450 dir
= qla1280_data_direction(cmd
);
3451 pkt
->control_flags
|= cpu_to_le16(dir
);
3453 /* Set total data segment count. */
3454 pkt
->dseg_count
= cpu_to_le16(seg_cnt
);
3457 * Load data segments.
3460 /* Setup packet address segment pointer. */
3461 dword_ptr
= &pkt
->dseg_0_address
;
3463 if (cmd
->use_sg
) { /* If scatter gather */
3464 dprintk(3, "Building S/G data segments..\n");
3465 qla1280_dump_buffer(1, (char *)sg
, 4 * 16);
3467 /* Load command entry data segments. */
3468 for (cnt
= 0; cnt
< 4 && seg_cnt
; cnt
++, seg_cnt
--) {
3470 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
)));
3472 cpu_to_le32(sg_dma_len(sg
));
3473 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3474 (pci_dma_lo32(sg_dma_address(sg
))),
3479 * Build continuation packets.
3481 dprintk(3, "S/G Building Continuation"
3482 "...seg_cnt=0x%x remains\n", seg_cnt
);
3483 while (seg_cnt
> 0) {
3484 /* Adjust ring index. */
3485 ha
->req_ring_index
++;
3486 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3487 ha
->req_ring_index
= 0;
3488 ha
->request_ring_ptr
=
3491 ha
->request_ring_ptr
++;
3493 pkt
= (struct cmd_entry
*)ha
->request_ring_ptr
;
3495 /* Zero out packet. */
3496 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3498 /* Load packet defaults. */
3499 ((struct cont_entry
*) pkt
)->
3500 entry_type
= CONTINUE_TYPE
;
3501 ((struct cont_entry
*) pkt
)->entry_count
= 1;
3503 ((struct cont_entry
*) pkt
)->sys_define
=
3504 (uint8_t) ha
->req_ring_index
;
3506 /* Setup packet address segment pointer. */
3508 &((struct cont_entry
*) pkt
)->dseg_0_address
;
3510 /* Load continuation entry data segments. */
3511 for (cnt
= 0; cnt
< 7 && seg_cnt
;
3514 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
)));
3516 cpu_to_le32(sg_dma_len(sg
));
3518 "S/G Segment Cont. phys_addr=0x%x, "
3520 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
))),
3521 cpu_to_le32(sg_dma_len(sg
)));
3524 dprintk(5, "qla1280_32bit_start_scsi: "
3525 "continuation packet data - "
3526 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd
),
3527 SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3528 qla1280_dump_buffer(5, (char *)pkt
,
3529 REQUEST_ENTRY_SIZE
);
3531 } else { /* No S/G data transfer */
3532 dma_handle
= pci_map_single(ha
->pdev
,
3533 cmd
->request_buffer
,
3534 cmd
->request_bufflen
,
3535 cmd
->sc_data_direction
);
3536 sp
->saved_dma_handle
= dma_handle
;
3538 *dword_ptr
++ = cpu_to_le32(pci_dma_lo32(dma_handle
));
3539 *dword_ptr
= cpu_to_le32(cmd
->request_bufflen
);
3541 } else { /* No data transfer at all */
3542 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3543 "packet data - \n");
3544 qla1280_dump_buffer(5, (char *)pkt
, REQUEST_ENTRY_SIZE
);
3546 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3547 qla1280_dump_buffer(5, (char *)ha
->request_ring_ptr
,
3548 REQUEST_ENTRY_SIZE
);
3550 /* Adjust ring index. */
3551 ha
->req_ring_index
++;
3552 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3553 ha
->req_ring_index
= 0;
3554 ha
->request_ring_ptr
= ha
->request_ring
;
3556 ha
->request_ring_ptr
++;
3558 /* Set chip new ring index. */
3559 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3560 "for pending command\n");
3561 sp
->flags
|= SRB_SENT
;
3563 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3564 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3569 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3571 LEAVE("qla1280_32bit_start_scsi");
3579 * Function is responsible for locking ring and
3580 * getting a zeroed out request packet.
3583 * ha = adapter block pointer.
3586 * 0 = failed to get slot.
3589 qla1280_req_pkt(struct scsi_qla_host
*ha
)
3591 struct device_reg __iomem
*reg
= ha
->iobase
;
3592 request_t
*pkt
= NULL
;
3596 ENTER("qla1280_req_pkt");
3599 * This can be called from interrupt context, damn it!!!
3601 /* Wait for 30 seconds for slot. */
3602 for (timer
= 15000000; timer
; timer
--) {
3603 if (ha
->req_q_cnt
> 0) {
3604 /* Calculate number of free request entries. */
3605 cnt
= RD_REG_WORD(®
->mailbox4
);
3606 if (ha
->req_ring_index
< cnt
)
3607 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3610 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3613 /* Found empty request ring slot? */
3614 if (ha
->req_q_cnt
> 0) {
3616 pkt
= ha
->request_ring_ptr
;
3618 /* Zero out packet. */
3619 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3622 * How can this be right when we have a ring
3625 /* Set system defined field. */
3626 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3628 /* Set entry count. */
3629 pkt
->entry_count
= 1;
3636 /* Check for pending interrupts. */
3641 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3643 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3650 * Function is responsible for modifying ISP input pointer.
3651 * Releases ring lock.
3654 * ha = adapter block pointer.
3657 qla1280_isp_cmd(struct scsi_qla_host
*ha
)
3659 struct device_reg __iomem
*reg
= ha
->iobase
;
3661 ENTER("qla1280_isp_cmd");
3663 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3664 qla1280_dump_buffer(5, (char *)ha
->request_ring_ptr
,
3665 REQUEST_ENTRY_SIZE
);
3667 /* Adjust ring index. */
3668 ha
->req_ring_index
++;
3669 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3670 ha
->req_ring_index
= 0;
3671 ha
->request_ring_ptr
= ha
->request_ring
;
3673 ha
->request_ring_ptr
++;
3676 * Update request index to mailbox4 (Request Queue In).
3677 * The mmiowb() ensures that this write is ordered with writes by other
3678 * CPUs. Without the mmiowb(), it is possible for the following:
3679 * CPUA posts write of index 5 to mailbox4
3680 * CPUA releases host lock
3681 * CPUB acquires host lock
3682 * CPUB posts write of index 6 to mailbox4
3683 * On PCI bus, order reverses and write of 6 posts, then index 5,
3684 * causing chip to issue full queue of stale commands
3685 * The mmiowb() prevents future writes from crossing the barrier.
3686 * See Documentation/DocBook/deviceiobook.tmpl for more information.
3688 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3691 LEAVE("qla1280_isp_cmd");
3694 /****************************************************************************/
3695 /* Interrupt Service Routine. */
3696 /****************************************************************************/
3698 /****************************************************************************
3700 * Calls I/O done on command completion.
3703 * ha = adapter block pointer.
3704 * done_q = done queue.
3705 ****************************************************************************/
3707 qla1280_isr(struct scsi_qla_host
*ha
, struct list_head
*done_q
)
3709 struct device_reg __iomem
*reg
= ha
->iobase
;
3710 struct response
*pkt
;
3711 struct srb
*sp
= NULL
;
3712 uint16_t mailbox
[MAILBOX_REGISTER_COUNT
];
3717 ENTER("qla1280_isr");
3719 istatus
= RD_REG_WORD(®
->istatus
);
3720 if (!(istatus
& (RISC_INT
| PCI_INT
)))
3723 /* Save mailbox register 5 */
3724 mailbox
[5] = RD_REG_WORD(®
->mailbox5
);
3726 /* Check for mailbox interrupt. */
3728 mailbox
[0] = RD_REG_WORD_dmasync(®
->semaphore
);
3730 if (mailbox
[0] & BIT_0
) {
3731 /* Get mailbox data. */
3732 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3735 *wptr
++ = RD_REG_WORD(®
->mailbox0
);
3736 *wptr
++ = RD_REG_WORD(®
->mailbox1
);
3737 *wptr
= RD_REG_WORD(®
->mailbox2
);
3738 if (mailbox
[0] != MBA_SCSI_COMPLETION
) {
3740 *wptr
++ = RD_REG_WORD(®
->mailbox3
);
3741 *wptr
++ = RD_REG_WORD(®
->mailbox4
);
3743 *wptr
++ = RD_REG_WORD(®
->mailbox6
);
3744 *wptr
= RD_REG_WORD(®
->mailbox7
);
3747 /* Release mailbox registers. */
3749 WRT_REG_WORD(®
->semaphore
, 0);
3750 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
3752 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3755 /* Handle asynchronous event */
3756 switch (mailbox
[0]) {
3757 case MBA_SCSI_COMPLETION
: /* Response completion */
3758 dprintk(5, "qla1280_isr: mailbox SCSI response "
3761 if (ha
->flags
.online
) {
3762 /* Get outstanding command index. */
3763 index
= mailbox
[2] << 16 | mailbox
[1];
3765 /* Validate handle. */
3766 if (index
< MAX_OUTSTANDING_COMMANDS
)
3767 sp
= ha
->outstanding_cmds
[index
];
3772 /* Free outstanding command slot. */
3773 ha
->outstanding_cmds
[index
] = NULL
;
3775 /* Save ISP completion status */
3776 CMD_RESULT(sp
->cmd
) = 0;
3778 /* Place block on done queue */
3779 list_add_tail(&sp
->list
, done_q
);
3782 * If we get here we have a real problem!
3785 "qla1280: ISP invalid handle");
3790 case MBA_BUS_RESET
: /* SCSI Bus Reset */
3791 ha
->flags
.reset_marker
= 1;
3792 index
= mailbox
[6] & BIT_0
;
3793 ha
->bus_settings
[index
].reset_marker
= 1;
3795 printk(KERN_DEBUG
"qla1280_isr(): index %i "
3796 "asynchronous BUS_RESET\n", index
);
3799 case MBA_SYSTEM_ERR
: /* System Error */
3801 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3802 "%xh, mbx3=%xh\n", mailbox
[1], mailbox
[2],
3806 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
3808 "qla1280: ISP Request Transfer Error\n");
3811 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
3813 "qla1280: ISP Response Transfer Error\n");
3816 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
3817 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3820 case MBA_TIMEOUT_RESET
: /* Execution Timeout Reset */
3822 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3825 case MBA_DEVICE_RESET
: /* Bus Device Reset */
3826 printk(KERN_INFO
"qla1280_isr(): asynchronous "
3827 "BUS_DEVICE_RESET\n");
3829 ha
->flags
.reset_marker
= 1;
3830 index
= mailbox
[6] & BIT_0
;
3831 ha
->bus_settings
[index
].reset_marker
= 1;
3834 case MBA_BUS_MODE_CHANGE
:
3836 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3840 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3841 if (mailbox
[0] < MBA_ASYNC_EVENT
) {
3843 memcpy((uint16_t *) ha
->mailbox_out
, wptr
,
3844 MAILBOX_REGISTER_COUNT
*
3847 if(ha
->mailbox_wait
!= NULL
)
3848 complete(ha
->mailbox_wait
);
3853 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
3857 * We will receive interrupts during mailbox testing prior to
3858 * the card being marked online, hence the double check.
3860 if (!(ha
->flags
.online
&& !ha
->mailbox_wait
)) {
3861 dprintk(2, "qla1280_isr: Response pointer Error\n");
3865 if (mailbox
[5] >= RESPONSE_ENTRY_CNT
)
3868 while (ha
->rsp_ring_index
!= mailbox
[5]) {
3869 pkt
= ha
->response_ring_ptr
;
3871 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3872 " = 0x%x\n", ha
->rsp_ring_index
, mailbox
[5]);
3873 dprintk(5,"qla1280_isr: response packet data\n");
3874 qla1280_dump_buffer(5, (char *)pkt
, RESPONSE_ENTRY_SIZE
);
3876 if (pkt
->entry_type
== STATUS_TYPE
) {
3877 if ((le16_to_cpu(pkt
->scsi_status
) & 0xff)
3878 || pkt
->comp_status
|| pkt
->entry_status
) {
3879 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3880 "0x%x mailbox[5] = 0x%x, comp_status "
3881 "= 0x%x, scsi_status = 0x%x\n",
3882 ha
->rsp_ring_index
, mailbox
[5],
3883 le16_to_cpu(pkt
->comp_status
),
3884 le16_to_cpu(pkt
->scsi_status
));
3887 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3888 "0x%x, mailbox[5] = 0x%x\n",
3889 ha
->rsp_ring_index
, mailbox
[5]);
3890 dprintk(2, "qla1280_isr: response packet data\n");
3891 qla1280_dump_buffer(2, (char *)pkt
,
3892 RESPONSE_ENTRY_SIZE
);
3895 if (pkt
->entry_type
== STATUS_TYPE
|| pkt
->entry_status
) {
3896 dprintk(2, "status: Cmd %p, handle %i\n",
3897 ha
->outstanding_cmds
[pkt
->handle
]->cmd
,
3899 if (pkt
->entry_type
== STATUS_TYPE
)
3900 qla1280_status_entry(ha
, pkt
, done_q
);
3902 qla1280_error_entry(ha
, pkt
, done_q
);
3903 /* Adjust ring index. */
3904 ha
->rsp_ring_index
++;
3905 if (ha
->rsp_ring_index
== RESPONSE_ENTRY_CNT
) {
3906 ha
->rsp_ring_index
= 0;
3907 ha
->response_ring_ptr
= ha
->response_ring
;
3909 ha
->response_ring_ptr
++;
3910 WRT_REG_WORD(®
->mailbox5
, ha
->rsp_ring_index
);
3915 LEAVE("qla1280_isr");
3920 * Processes asynchronous reset.
3923 * ha = adapter block pointer.
3926 qla1280_rst_aen(struct scsi_qla_host
*ha
)
3930 ENTER("qla1280_rst_aen");
3932 if (ha
->flags
.online
&& !ha
->flags
.reset_active
&&
3933 !ha
->flags
.abort_isp_active
) {
3934 ha
->flags
.reset_active
= 1;
3935 while (ha
->flags
.reset_marker
) {
3936 /* Issue marker command. */
3937 ha
->flags
.reset_marker
= 0;
3938 for (bus
= 0; bus
< ha
->ports
&&
3939 !ha
->flags
.reset_marker
; bus
++) {
3940 if (ha
->bus_settings
[bus
].reset_marker
) {
3941 ha
->bus_settings
[bus
].reset_marker
= 0;
3942 qla1280_marker(ha
, bus
, 0, 0,
3949 LEAVE("qla1280_rst_aen");
3953 #if LINUX_VERSION_CODE < 0x020500
3958 qla1280_get_target_options(struct scsi_cmnd
*cmd
, struct scsi_qla_host
*ha
)
3960 unsigned char *result
;
3962 int bus
, target
, lun
;
3964 bus
= SCSI_BUS_32(cmd
);
3965 target
= SCSI_TCN_32(cmd
);
3966 lun
= SCSI_LUN_32(cmd
);
3969 * Make sure to not touch anything if someone is using the
3972 if (cmd
->use_sg
|| (CMD_RESULT(cmd
) >> 16) != DID_OK
|| lun
)
3975 result
= cmd
->request_buffer
;
3978 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 0;
3979 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 0;
3980 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 0;
3982 if (result
[7] & 0x60)
3983 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 1;
3984 if (result
[7] & 0x10)
3985 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 1;
3986 if ((result
[2] >= 3) && (result
[4] + 5 > 56) &&
3988 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 1;
3990 dprintk(2, "get_target_options(): wide %i, sync %i, ppr %i\n",
3991 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
,
3992 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
,
3993 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
);
3998 * qla1280_status_entry
3999 * Processes received ISP status entry.
4002 * ha = adapter block pointer.
4003 * pkt = entry pointer.
4004 * done_q = done queue.
4007 qla1280_status_entry(struct scsi_qla_host
*ha
, struct response
*pkt
,
4008 struct list_head
*done_q
)
4010 unsigned int bus
, target
, lun
;
4013 struct scsi_cmnd
*cmd
;
4014 uint32_t handle
= le32_to_cpu(pkt
->handle
);
4015 uint16_t scsi_status
= le16_to_cpu(pkt
->scsi_status
);
4016 uint16_t comp_status
= le16_to_cpu(pkt
->comp_status
);
4018 ENTER("qla1280_status_entry");
4020 /* Validate handle. */
4021 if (handle
< MAX_OUTSTANDING_COMMANDS
)
4022 sp
= ha
->outstanding_cmds
[handle
];
4027 printk(KERN_WARNING
"qla1280: Status Entry invalid handle\n");
4031 /* Free outstanding command slot. */
4032 ha
->outstanding_cmds
[handle
] = NULL
;
4036 /* Generate LU queue on cntrl, target, LUN */
4037 bus
= SCSI_BUS_32(cmd
);
4038 target
= SCSI_TCN_32(cmd
);
4039 lun
= SCSI_LUN_32(cmd
);
4041 if (comp_status
|| scsi_status
) {
4042 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
4043 "0x%x, handle = 0x%x\n", comp_status
,
4044 scsi_status
, handle
);
4047 /* Target busy or queue full */
4048 if ((scsi_status
& 0xFF) == SAM_STAT_TASK_SET_FULL
||
4049 (scsi_status
& 0xFF) == SAM_STAT_BUSY
) {
4050 CMD_RESULT(cmd
) = scsi_status
& 0xff;
4053 /* Save ISP completion status */
4054 CMD_RESULT(cmd
) = qla1280_return_status(pkt
, cmd
);
4056 if (scsi_status
& SS_CHECK_CONDITION
) {
4057 if (comp_status
!= CS_ARS_FAILED
) {
4058 uint16_t req_sense_length
=
4059 le16_to_cpu(pkt
->req_sense_length
);
4060 if (req_sense_length
< CMD_SNSLEN(cmd
))
4061 sense_sz
= req_sense_length
;
4064 * scsi_cmnd->sense_buffer is
4065 * 64 bytes, why only copy 63?
4066 * This looks wrong! /Jes
4068 sense_sz
= CMD_SNSLEN(cmd
) - 1;
4070 memcpy(cmd
->sense_buffer
,
4071 &pkt
->req_sense_data
, sense_sz
);
4074 memset(cmd
->sense_buffer
+ sense_sz
, 0,
4075 sizeof(cmd
->sense_buffer
) - sense_sz
);
4077 dprintk(2, "qla1280_status_entry: Check "
4078 "condition Sense data, b %i, t %i, "
4079 "l %i\n", bus
, target
, lun
);
4081 qla1280_dump_buffer(2,
4082 (char *)cmd
->sense_buffer
,
4087 /* Place command on done queue. */
4088 list_add_tail(&sp
->list
, done_q
);
4090 LEAVE("qla1280_status_entry");
4094 * qla1280_error_entry
4095 * Processes error entry.
4098 * ha = adapter block pointer.
4099 * pkt = entry pointer.
4100 * done_q = done queue.
4103 qla1280_error_entry(struct scsi_qla_host
*ha
, struct response
*pkt
,
4104 struct list_head
*done_q
)
4107 uint32_t handle
= le32_to_cpu(pkt
->handle
);
4109 ENTER("qla1280_error_entry");
4111 if (pkt
->entry_status
& BIT_3
)
4112 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
4113 else if (pkt
->entry_status
& BIT_2
)
4114 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
4115 else if (pkt
->entry_status
& BIT_1
)
4116 dprintk(2, "qla1280_error_entry: FULL flag error\n");
4118 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
4120 /* Validate handle. */
4121 if (handle
< MAX_OUTSTANDING_COMMANDS
)
4122 sp
= ha
->outstanding_cmds
[handle
];
4127 /* Free outstanding command slot. */
4128 ha
->outstanding_cmds
[handle
] = NULL
;
4130 /* Bad payload or header */
4131 if (pkt
->entry_status
& (BIT_3
+ BIT_2
)) {
4132 /* Bad payload or header, set error status. */
4133 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
4134 CMD_RESULT(sp
->cmd
) = DID_ERROR
<< 16;
4135 } else if (pkt
->entry_status
& BIT_1
) { /* FULL flag */
4136 CMD_RESULT(sp
->cmd
) = DID_BUS_BUSY
<< 16;
4138 /* Set error status. */
4139 CMD_RESULT(sp
->cmd
) = DID_ERROR
<< 16;
4142 /* Place command on done queue. */
4143 list_add_tail(&sp
->list
, done_q
);
4145 #ifdef QLA_64BIT_PTR
4146 else if (pkt
->entry_type
== COMMAND_A64_TYPE
) {
4147 printk(KERN_WARNING
"!qla1280: Error Entry invalid handle");
4151 LEAVE("qla1280_error_entry");
4156 * Resets ISP and aborts all outstanding commands.
4159 * ha = adapter block pointer.
4165 qla1280_abort_isp(struct scsi_qla_host
*ha
)
4167 struct device_reg __iomem
*reg
= ha
->iobase
;
4173 ENTER("qla1280_abort_isp");
4175 if (ha
->flags
.abort_isp_active
|| !ha
->flags
.online
)
4178 ha
->flags
.abort_isp_active
= 1;
4180 /* Disable ISP interrupts. */
4181 qla1280_disable_intrs(ha
);
4182 WRT_REG_WORD(®
->host_cmd
, HC_PAUSE_RISC
);
4183 RD_REG_WORD(®
->id_l
);
4185 printk(KERN_INFO
"scsi(%li): dequeuing outstanding commands\n",
4187 /* Dequeue all commands in outstanding command list. */
4188 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++) {
4189 struct scsi_cmnd
*cmd
;
4190 sp
= ha
->outstanding_cmds
[cnt
];
4194 CMD_RESULT(cmd
) = DID_RESET
<< 16;
4197 ha
->outstanding_cmds
[cnt
] = NULL
;
4199 (*cmd
->scsi_done
)(cmd
);
4205 status
= qla1280_load_firmware(ha
);
4209 /* Setup adapter based on NVRAM parameters. */
4210 qla1280_nvram_config (ha
);
4212 status
= qla1280_init_rings(ha
);
4216 /* Issue SCSI reset. */
4217 for (bus
= 0; bus
< ha
->ports
; bus
++)
4218 qla1280_bus_reset(ha
, bus
);
4220 ha
->flags
.abort_isp_active
= 0;
4224 "qla1280: ISP error recovery failed, board disabled");
4225 qla1280_reset_adapter(ha
);
4226 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
4229 LEAVE("qla1280_abort_isp");
4235 * qla1280_debounce_register
4236 * Debounce register.
4239 * port = register address.
4245 qla1280_debounce_register(volatile u16 __iomem
* addr
)
4250 ret
= RD_REG_WORD(addr
);
4251 ret2
= RD_REG_WORD(addr
);
4258 ret
= RD_REG_WORD(addr
);
4259 ret2
= RD_REG_WORD(addr
);
4260 } while (ret
!= ret2
);
4266 /************************************************************************
4267 * qla1280_check_for_dead_scsi_bus *
4269 * This routine checks for a dead SCSI bus *
4270 ************************************************************************/
4271 #define SET_SXP_BANK 0x0100
4272 #define SCSI_PHASE_INVALID 0x87FF
4274 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host
*ha
, unsigned int bus
)
4276 uint16_t config_reg
, scsi_control
;
4277 struct device_reg __iomem
*reg
= ha
->iobase
;
4279 if (ha
->bus_settings
[bus
].scsi_bus_dead
) {
4280 WRT_REG_WORD(®
->host_cmd
, HC_PAUSE_RISC
);
4281 config_reg
= RD_REG_WORD(®
->cfg_1
);
4282 WRT_REG_WORD(®
->cfg_1
, SET_SXP_BANK
);
4283 scsi_control
= RD_REG_WORD(®
->scsiControlPins
);
4284 WRT_REG_WORD(®
->cfg_1
, config_reg
);
4285 WRT_REG_WORD(®
->host_cmd
, HC_RELEASE_RISC
);
4287 if (scsi_control
== SCSI_PHASE_INVALID
) {
4288 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
4290 CMD_RESULT(cp
) = DID_NO_CONNECT
<< 16;
4291 CMD_HANDLE(cp
) = INVALID_HANDLE
;
4292 /* ha->actthreads--; */
4294 (*(cp
)->scsi_done
)(cp
);
4296 return 1; /* bus is dead */
4298 ha
->bus_settings
[bus
].scsi_bus_dead
= 0;
4299 ha
->bus_settings
[bus
].failed_reset_count
= 0;
4302 return 0; /* bus is not dead */
4306 qla1280_get_target_parameters(struct scsi_qla_host
*ha
,
4307 struct scsi_device
*device
)
4309 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
4310 int bus
, target
, lun
;
4312 bus
= device
->channel
;
4313 target
= device
->id
;
4317 mb
[0] = MBC_GET_TARGET_PARAMETERS
;
4318 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
4320 qla1280_mailbox_command(ha
, BIT_6
| BIT_3
| BIT_2
| BIT_1
| BIT_0
,
4323 printk(KERN_INFO
"scsi(%li:%d:%d:%d):", ha
->host_no
, bus
, target
, lun
);
4326 printk(" Sync: period %d, offset %d",
4327 (mb
[3] & 0xff), (mb
[3] >> 8));
4330 if ((mb
[2] & BIT_5
) && ((mb
[6] >> 8) & 0xff) >= 2)
4335 if (DEV_SIMPLE_TAGS(device
))
4336 printk(", Tagged queuing: depth %d", device
->queue_depth
);
4343 __qla1280_dump_buffer(char *b
, int size
)
4348 printk(KERN_DEBUG
" 0 1 2 3 4 5 6 7 8 9 Ah "
4349 "Bh Ch Dh Eh Fh\n");
4350 printk(KERN_DEBUG
"---------------------------------------------"
4351 "------------------\n");
4353 for (cnt
= 0; cnt
< size
;) {
4356 printk("0x%02x", c
);
4367 /**************************************************************************
4368 * ql1280_print_scsi_cmd
4370 **************************************************************************/
4372 __qla1280_print_scsi_cmd(struct scsi_cmnd
*cmd
)
4374 struct scsi_qla_host
*ha
;
4375 struct Scsi_Host
*host
= CMD_HOST(cmd
);
4377 /* struct scatterlist *sg; */
4380 ha
= (struct scsi_qla_host
*)host
->hostdata
;
4382 sp
= (struct srb
*)CMD_SP(cmd
);
4383 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd
, CMD_HANDLE(cmd
));
4384 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4385 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
),
4388 for (i
= 0; i
< cmd
->cmd_len
; i
++) {
4389 printk("0x%02x ", cmd
->cmnd
[i
]);
4391 printk(" seg_cnt =%d\n", cmd
->use_sg
);
4392 printk(" request buffer=0x%p, request buffer len=0x%x\n",
4393 cmd
->request_buffer
, cmd
->request_bufflen
);
4396 sg = (struct scatterlist *) cmd->request_buffer;
4397 printk(" SG buffer: \n");
4398 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4400 printk(" tag=%d, transfersize=0x%x \n",
4401 cmd
->tag
, cmd
->transfersize
);
4402 printk(" Pid=%li, SP=0x%p\n", cmd
->pid
, CMD_SP(cmd
));
4403 printk(" underflow size = 0x%x, direction=0x%x\n",
4404 cmd
->underflow
, cmd
->sc_data_direction
);
4407 /**************************************************************************
4408 * ql1280_dump_device
4410 **************************************************************************/
4412 ql1280_dump_device(struct scsi_qla_host
*ha
)
4415 struct scsi_cmnd
*cp
;
4419 printk(KERN_DEBUG
"Outstanding Commands on controller:\n");
4421 for (i
= 0; i
< MAX_OUTSTANDING_COMMANDS
; i
++) {
4422 if ((sp
= ha
->outstanding_cmds
[i
]) == NULL
)
4424 if ((cp
= sp
->cmd
) == NULL
)
4426 qla1280_print_scsi_cmd(1, cp
);
4441 struct setup_tokens
{
4446 static struct setup_tokens setup_token
[] __initdata
=
4448 { "nvram", TOKEN_NVRAM
},
4449 { "sync", TOKEN_SYNC
},
4450 { "wide", TOKEN_WIDE
},
4451 { "ppr", TOKEN_PPR
},
4452 { "verbose", TOKEN_VERBOSE
},
4453 { "debug", TOKEN_DEBUG
},
4457 /**************************************************************************
4460 * Handle boot parameters. This really needs to be changed so one
4461 * can specify per adapter parameters.
4462 **************************************************************************/
4464 qla1280_setup(char *s
)
4472 while (cp
&& (ptr
= strchr(cp
, ':'))) {
4474 if (!strcmp(ptr
, "yes")) {
4477 } else if (!strcmp(ptr
, "no")) {
4481 val
= simple_strtoul(ptr
, &ptr
, 0);
4483 switch ((toke
= qla1280_get_token(cp
))) {
4486 driver_setup
.no_nvram
= 1;
4490 driver_setup
.no_sync
= 1;
4491 else if (val
!= 0x10000)
4492 driver_setup
.sync_mask
= val
;
4496 driver_setup
.no_wide
= 1;
4497 else if (val
!= 0x10000)
4498 driver_setup
.wide_mask
= val
;
4502 driver_setup
.no_ppr
= 1;
4503 else if (val
!= 0x10000)
4504 driver_setup
.ppr_mask
= val
;
4507 qla1280_verbose
= val
;
4510 printk(KERN_INFO
"qla1280: unknown boot option %s\n",
4514 cp
= strchr(ptr
, ';');
4526 qla1280_get_token(char *str
)
4532 len
= sizeof(setup_token
)/sizeof(struct setup_tokens
);
4534 sep
= strchr(str
, ':');
4537 for (i
= 0; i
< len
; i
++){
4539 if (!strncmp(setup_token
[i
].token
, str
, (sep
- str
))) {
4540 ret
= setup_token
[i
].val
;
4549 #if LINUX_VERSION_CODE >= 0x020600
4550 static struct scsi_host_template qla1280_driver_template
= {
4551 .module
= THIS_MODULE
,
4552 .proc_name
= "qla1280",
4553 .name
= "Qlogic ISP 1280/12160",
4554 .info
= qla1280_info
,
4555 .slave_configure
= qla1280_slave_configure
,
4556 .queuecommand
= qla1280_queuecommand
,
4557 .eh_abort_handler
= qla1280_eh_abort
,
4558 .eh_device_reset_handler
= qla1280_eh_device_reset
,
4559 .eh_bus_reset_handler
= qla1280_eh_bus_reset
,
4560 .eh_host_reset_handler
= qla1280_eh_adapter_reset
,
4561 .bios_param
= qla1280_biosparam
,
4562 .can_queue
= 0xfffff,
4564 .sg_tablesize
= SG_ALL
,
4566 .use_clustering
= ENABLE_CLUSTERING
,
4569 static Scsi_Host_Template qla1280_driver_template
= {
4570 .proc_name
= "qla1280",
4571 .name
= "Qlogic ISP 1280/12160",
4572 .detect
= qla1280_detect
,
4573 .release
= qla1280_release
,
4574 .info
= qla1280_info
,
4575 .queuecommand
= qla1280_queuecommand
,
4576 .eh_abort_handler
= qla1280_eh_abort
,
4577 .eh_device_reset_handler
= qla1280_eh_device_reset
,
4578 .eh_bus_reset_handler
= qla1280_eh_bus_reset
,
4579 .eh_host_reset_handler
= qla1280_eh_adapter_reset
,
4580 .bios_param
= qla1280_biosparam_old
,
4581 .can_queue
= 0xfffff,
4583 .sg_tablesize
= SG_ALL
,
4585 .use_clustering
= ENABLE_CLUSTERING
,
4586 .use_new_eh_code
= 1,
4590 static int __devinit
4591 qla1280_probe_one(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
4593 int devnum
= id
->driver_data
;
4594 struct qla_boards
*bdp
= &ql1280_board_tbl
[devnum
];
4595 struct Scsi_Host
*host
;
4596 struct scsi_qla_host
*ha
;
4597 int error
= -ENODEV
;
4599 /* Bypass all AMI SUBSYS VENDOR IDs */
4600 if (pdev
->subsystem_vendor
== PCI_VENDOR_ID_AMI
) {
4602 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4606 printk(KERN_INFO
"qla1280: %s found on PCI bus %i, dev %i\n",
4607 bdp
->name
, pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
));
4609 if (pci_enable_device(pdev
)) {
4611 "qla1280: Failed to enabled pci device, aborting.\n");
4615 pci_set_master(pdev
);
4618 host
= scsi_host_alloc(&qla1280_driver_template
, sizeof(*ha
));
4621 "qla1280: Failed to register host, aborting.\n");
4622 goto error_disable_device
;
4625 ha
= (struct scsi_qla_host
*)host
->hostdata
;
4626 memset(ha
, 0, sizeof(struct scsi_qla_host
));
4629 ha
->devnum
= devnum
; /* specifies microcode load address */
4631 #ifdef QLA_64BIT_PTR
4632 if (pci_set_dma_mask(ha
->pdev
, (dma_addr_t
) ~ 0ULL)) {
4633 if (pci_set_dma_mask(ha
->pdev
, 0xffffffff)) {
4634 printk(KERN_WARNING
"scsi(%li): Unable to set a "
4635 " suitable DMA mask - aboring\n", ha
->host_no
);
4637 goto error_free_irq
;
4640 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4643 if (pci_set_dma_mask(ha
->pdev
, 0xffffffff)) {
4644 printk(KERN_WARNING
"scsi(%li): Unable to set a "
4645 " suitable DMA mask - aboring\n", ha
->host_no
);
4647 goto error_free_irq
;
4651 ha
->request_ring
= pci_alloc_consistent(ha
->pdev
,
4652 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4654 if (!ha
->request_ring
) {
4655 printk(KERN_INFO
"qla1280: Failed to get request memory\n");
4656 goto error_put_host
;
4659 ha
->response_ring
= pci_alloc_consistent(ha
->pdev
,
4660 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4662 if (!ha
->response_ring
) {
4663 printk(KERN_INFO
"qla1280: Failed to get response memory\n");
4664 goto error_free_request_ring
;
4667 ha
->ports
= bdp
->numPorts
;
4670 ha
->host_no
= host
->host_no
;
4672 host
->irq
= pdev
->irq
;
4673 host
->max_channel
= bdp
->numPorts
- 1;
4674 host
->max_lun
= MAX_LUNS
- 1;
4675 host
->max_id
= MAX_TARGETS
;
4676 host
->max_sectors
= 1024;
4677 host
->unique_id
= host
->host_no
;
4679 #if LINUX_VERSION_CODE < 0x020545
4680 host
->select_queue_depths
= qla1280_select_queue_depth
;
4685 #if MEMORY_MAPPED_IO
4686 ha
->mmpbase
= ioremap(pci_resource_start(ha
->pdev
, 1),
4687 pci_resource_len(ha
->pdev
, 1));
4689 printk(KERN_INFO
"qla1280: Unable to map I/O memory\n");
4690 goto error_free_response_ring
;
4693 host
->base
= (unsigned long)ha
->mmpbase
;
4694 ha
->iobase
= (struct device_reg __iomem
*)ha
->mmpbase
;
4696 host
->io_port
= pci_resource_start(ha
->pdev
, 0);
4697 if (!request_region(host
->io_port
, 0xff, "qla1280")) {
4698 printk(KERN_INFO
"qla1280: Failed to reserve i/o region "
4699 "0x%04lx-0x%04lx - already in use\n",
4700 host
->io_port
, host
->io_port
+ 0xff);
4701 goto error_free_response_ring
;
4704 ha
->iobase
= (struct device_reg
*)host
->io_port
;
4707 INIT_LIST_HEAD(&ha
->done_q
);
4709 /* Disable ISP interrupts. */
4710 qla1280_disable_intrs(ha
);
4712 if (request_irq(pdev
->irq
, qla1280_intr_handler
, SA_SHIRQ
,
4714 printk("qla1280 : Failed to reserve interrupt %d already "
4715 "in use\n", pdev
->irq
);
4716 goto error_release_region
;
4719 /* load the F/W, read paramaters, and init the H/W */
4720 if (qla1280_initialize_adapter(ha
)) {
4721 printk(KERN_INFO
"qla1x160: Failed to initialize adapter\n");
4722 goto error_free_irq
;
4725 /* set our host ID (need to do something about our two IDs) */
4726 host
->this_id
= ha
->bus_settings
[0].id
;
4728 pci_set_drvdata(pdev
, host
);
4730 #if LINUX_VERSION_CODE >= 0x020600
4731 error
= scsi_add_host(host
, &pdev
->dev
);
4733 goto error_disable_adapter
;
4734 scsi_scan_host(host
);
4736 scsi_set_pci_device(host
, pdev
);
4741 #if LINUX_VERSION_CODE >= 0x020600
4742 error_disable_adapter
:
4743 WRT_REG_WORD(&ha
->iobase
->ictrl
, 0);
4746 free_irq(pdev
->irq
, ha
);
4747 error_release_region
:
4748 #if MEMORY_MAPPED_IO
4749 iounmap(ha
->mmpbase
);
4751 release_region(host
->io_port
, 0xff);
4753 error_free_response_ring
:
4754 pci_free_consistent(ha
->pdev
,
4755 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4756 ha
->response_ring
, ha
->response_dma
);
4757 error_free_request_ring
:
4758 pci_free_consistent(ha
->pdev
,
4759 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4760 ha
->request_ring
, ha
->request_dma
);
4762 scsi_host_put(host
);
4763 error_disable_device
:
4764 pci_disable_device(pdev
);
4770 static void __devexit
4771 qla1280_remove_one(struct pci_dev
*pdev
)
4773 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
4774 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
4776 #if LINUX_VERSION_CODE >= 0x020600
4777 scsi_remove_host(host
);
4780 WRT_REG_WORD(&ha
->iobase
->ictrl
, 0);
4782 free_irq(pdev
->irq
, ha
);
4784 #if MEMORY_MAPPED_IO
4785 iounmap(ha
->mmpbase
);
4787 release_region(host
->io_port
, 0xff);
4790 pci_free_consistent(ha
->pdev
,
4791 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4792 ha
->request_ring
, ha
->request_dma
);
4793 pci_free_consistent(ha
->pdev
,
4794 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4795 ha
->response_ring
, ha
->response_dma
);
4797 pci_disable_device(pdev
);
4799 scsi_host_put(host
);
4802 #if LINUX_VERSION_CODE >= 0x020600
4803 static struct pci_driver qla1280_pci_driver
= {
4805 .id_table
= qla1280_pci_tbl
,
4806 .probe
= qla1280_probe_one
,
4807 .remove
= __devexit_p(qla1280_remove_one
),
4813 if (sizeof(struct srb
) > sizeof(struct scsi_pointer
)) {
4815 "qla1280: struct srb too big, aborting\n");
4821 * If we are called as a module, the qla1280 pointer may not be null
4822 * and it would point to our bootup string, just like on the lilo
4823 * command line. IF not NULL, then process this config string with
4827 * To add options at boot time add a line to your lilo.conf file like:
4828 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4829 * which will result in the first four devices on the first two
4830 * controllers being set to a tagged queue depth of 32.
4833 qla1280_setup(qla1280
);
4836 return pci_module_init(&qla1280_pci_driver
);
4842 pci_unregister_driver(&qla1280_pci_driver
);
4845 module_init(qla1280_init
);
4846 module_exit(qla1280_exit
);
4849 # define driver_template qla1280_driver_template
4850 # include "scsi_module.c"
4853 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4854 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4855 MODULE_LICENSE("GPL");
4856 MODULE_VERSION(QLA1280_VERSION
);
4859 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4860 * Emacs will notice this stuff at the end of the file and automatically
4861 * adjust the settings for this buffer only. This must remain at the end
4863 * ---------------------------------------------------------------------------