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.24.4"
21 /*****************************************************************************
23 Rev 3.24.4 June 7, 2004 Christoph Hellwig
24 - restructure firmware loading, cleanup initialization code
25 - prepare support for ISP1020/1040 chips
26 Rev 3.24.3 January 19, 2004, Jes Sorensen
27 - Handle PCI DMA mask settings correctly
28 - Correct order of error handling in probe_one, free_irq should not
29 be called if request_irq failed
30 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
31 - Big endian fixes (James)
32 - Remove bogus IOCB content on zero data transfer commands (Andrew)
33 Rev 3.24.1 January 5, 2004, Jes Sorensen
34 - Initialize completion queue to avoid OOPS on probe
35 - Handle interrupts during mailbox testing
36 Rev 3.24 November 17, 2003, Christoph Hellwig
37 - use struct list_head for completion queue
38 - avoid old Scsi_FOO typedefs
39 - cleanup 2.4 compat glue a bit
40 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
41 - make initialization for memory mapped vs port I/O more similar
42 - remove broken pci config space manipulation
44 - this is an almost perfect 2.6 scsi driver now! ;)
45 Rev 3.23.39 December 17, 2003, Jes Sorensen
46 - Delete completion queue from srb if mailbox command failed to
47 to avoid qla1280_done completeting qla1280_error_action's
49 - Reduce arguments for qla1280_done
50 Rev 3.23.38 October 18, 2003, Christoph Hellwig
51 - Convert to new-style hotplugable driver for 2.6
52 - Fix missing scsi_unregister/scsi_host_put on HBA removal
53 - Kill some more cruft
54 Rev 3.23.37 October 1, 2003, Jes Sorensen
55 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
57 - Clean up locking in probe path
58 Rev 3.23.36 October 1, 2003, Christoph Hellwig
59 - queuecommand only ever receives new commands - clear flags
60 - Reintegrate lost fixes from Linux 2.5
61 Rev 3.23.35 August 14, 2003, Jes Sorensen
63 Rev 3.23.34 July 23, 2003, Jes Sorensen
64 - Remove pointless TRUE/FALSE macros
65 - Clean up vchan handling
66 Rev 3.23.33 July 3, 2003, Jes Sorensen
67 - Don't define register access macros before define determining MMIO.
68 This just happend to work out on ia64 but not elsewhere.
69 - Don't try and read from the card while it is in reset as
70 it won't respond and causes an MCA
71 Rev 3.23.32 June 23, 2003, Jes Sorensen
72 - Basic support for boot time arguments
73 Rev 3.23.31 June 8, 2003, Jes Sorensen
74 - Reduce boot time messages
75 Rev 3.23.30 June 6, 2003, Jes Sorensen
76 - Do not enable sync/wide/ppr before it has been determined
77 that the target device actually supports it
78 - Enable DMA arbitration for multi channel controllers
79 Rev 3.23.29 June 3, 2003, Jes Sorensen
81 Rev 3.23.28 June 3, 2003, Jes Sorensen
82 - Eliminate duplicate marker commands on bus resets
83 - Handle outstanding commands appropriately on bus/device resets
84 Rev 3.23.27 May 28, 2003, Jes Sorensen
85 - Remove bogus input queue code, let the Linux SCSI layer do the work
86 - Clean up NVRAM handling, only read it once from the card
87 - Add a number of missing default nvram parameters
88 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
89 - Use completion queue for mailbox commands instead of busy wait
90 Rev 3.23.25 Beta May 27, 2003, James Bottomley
91 - Migrate to use new error handling code
92 Rev 3.23.24 Beta May 21, 2003, James Bottomley
94 - Cleanup data direction code
95 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
96 - Switch to using MMIO instead of PIO
97 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
98 - Fix PCI parity problem with 12160 during reset.
99 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
100 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
101 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
102 - Remove < 2.4.x support
103 - Introduce HOST_LOCK to make the spin lock changes portable.
104 - Remove a bunch of idiotic and unnecessary typedef's
105 - Kill all leftovers of target-mode support which never worked anyway
106 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
107 - Do qla1280_pci_config() before calling request_irq() and
109 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
111 - Hand correct arguments to free_irq() in case of failure
112 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
113 - Run source through Lindent and clean up the output
114 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
115 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
116 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
117 - Rely on mailbox commands generating interrupts - do not
118 run qla1280_isr() from ql1280_mailbox_command()
119 - Remove device_reg_t
120 - Integrate ql12160_set_target_parameters() with 1280 version
121 - Make qla1280_setup() non static
122 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
123 sent to the card - this command pauses the firmare!!!
124 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
125 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
126 - Remove a pile of pointless and confusing (srb_t **) and
127 (scsi_lu_t *) typecasts
128 - Explicit mark that we do not use the new error handling (for now)
129 - Remove scsi_qla_host_t and use 'struct' instead
130 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
131 pci_64bit_slot flags which weren't used for anything anyway
132 - Grab host->host_lock while calling qla1280_isr() from abort()
133 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
134 do not need to save/restore flags in the interrupt handler
135 - Enable interrupts early (before any mailbox access) in preparation
136 for cleaning up the mailbox handling
137 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
138 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
139 it with proper use of dprintk().
140 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
141 a debug level argument to determine if data is to be printed
142 - Add KERN_* info to printk()
143 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
144 - Significant cosmetic cleanups
145 - Change debug code to use dprintk() and remove #if mess
146 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
147 - More cosmetic cleanups, fix places treating return as function
148 - use cpu_relax() in qla1280_debounce_register()
149 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
150 - Make it compile under 2.5.5
151 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
152 - Do no typecast short * to long * in QL1280BoardTbl, this
153 broke miserably on big endian boxes
154 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
155 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
156 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
157 unsigned int to match the types from struct scsi_cmnd
158 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
159 - Remove bogus timer_t typedef from qla1280.h
160 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
161 for PCI_ values, call pci_set_master()
162 - Fix memleak of qla1280_buffer on module unload
163 - Only compile module parsing code #ifdef MODULE - should be
164 changed to use individual MODULE_PARM's later
165 - Remove dummy_buffer that was never modified nor printed
166 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
167 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
168 - Remove \r from print statements, this is Linux, not DOS
169 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
171 - Remove C++ compile hack in header file as Linux driver are not
172 supposed to be compiled as C++
173 - Kill MS_64BITS macro as it makes the code more readable
174 - Remove unnecessary flags.in_interrupts bit
175 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
176 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
177 - Check whether the interrupt was generated by the QLA1280 before
179 - qla1280_status_entry(): Only zero out part of sense_buffer that
180 is not being copied into
181 - Remove more superflouous typecasts
182 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
183 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
184 - Don't walk the entire list in qla1280_putq_t() just to directly
185 grab the pointer to the last element afterwards
186 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
187 - Don't use SA_INTERRUPT, it's use is deprecated for this kinda driver
188 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
189 - Set dev->max_sectors to 1024
190 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
191 - Provide compat macros for pci_enable_device(), pci_find_subsys()
192 and scsi_set_pci_device()
193 - Call scsi_set_pci_device() for all devices
194 - Reduce size of kernel version dependent device probe code
195 - Move duplicate probe/init code to separate function
196 - Handle error if qla1280_mem_alloc() fails
197 - Kill OFFSET() macro and use Linux's PCI definitions instead
198 - Kill private structure defining PCI config space (struct config_reg)
199 - Only allocate I/O port region if not in MMIO mode
200 - Remove duplicate (unused) sanity check of sife of srb_t
201 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
202 - Change home-brew memset() implementations to use memset()
203 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
204 port directly is not legal under Linux.
205 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
206 - Remove pre 2.2 kernel support
207 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
208 - Fix MMIO access to use readl/writel instead of directly
209 dereferencing pointers
210 - Nuke MSDOS debugging code
211 - Change true/false data types to int from uint8_t
212 - Use int for counters instead of uint8_t etc.
213 - Clean up size & byte order conversion macro usage
214 Rev 3.23 Beta January 11, 2001 BN Qlogic
215 - Added check of device_id when handling non
216 QLA12160s during detect().
217 Rev 3.22 Beta January 5, 2001 BN Qlogic
218 - Changed queue_task() to schedule_task()
219 for kernels 2.4.0 and higher.
220 Note: 2.4.0-testxx kernels released prior to
221 the actual 2.4.0 kernel release on January 2001
222 will get compile/link errors with schedule_task().
223 Please update your kernel to released 2.4.0 level,
224 or comment lines in this file flagged with 3.22
225 to resolve compile/link error of schedule_task().
226 - Added -DCONFIG_SMP in addition to -D__SMP__
227 in Makefile for 2.4.0 builds of driver as module.
228 Rev 3.21 Beta January 4, 2001 BN Qlogic
229 - Changed criteria of 64/32 Bit mode of HBA
230 operation according to BITS_PER_LONG rather
231 than HBA's NVRAM setting of >4Gig memory bit;
232 so that the HBA auto-configures without the need
233 to setup each system individually.
234 Rev 3.20 Beta December 5, 2000 BN Qlogic
235 - Added priority handling to IA-64 onboard SCSI
236 ISP12160 chip for kernels greater than 2.3.18.
237 - Added irqrestore for qla1280_intr_handler.
238 - Enabled /proc/scsi/qla1280 interface.
239 - Clear /proc/scsi/qla1280 counters in detect().
240 Rev 3.19 Beta October 13, 2000 BN Qlogic
241 - Declare driver_template for new kernel
242 (2.4.0 and greater) scsi initialization scheme.
243 - Update /proc/scsi entry for 2.3.18 kernels and
245 Rev 3.18 Beta October 10, 2000 BN Qlogic
246 - Changed scan order of adapters to map
247 the QLA12160 followed by the QLA1280.
248 Rev 3.17 Beta September 18, 2000 BN Qlogic
249 - Removed warnings for 32 bit 2.4.x compiles
250 - Corrected declared size for request and response
251 DMA addresses that are kept in each ha
252 Rev. 3.16 Beta August 25, 2000 BN Qlogic
253 - Corrected 64 bit addressing issue on IA-64
254 where the upper 32 bits were not properly
255 passed to the RISC engine.
256 Rev. 3.15 Beta August 22, 2000 BN Qlogic
257 - Modified qla1280_setup_chip to properly load
258 ISP firmware for greater that 4 Gig memory on IA-64
259 Rev. 3.14 Beta August 16, 2000 BN Qlogic
260 - Added setting of dma_mask to full 64 bit
261 if flags.enable_64bit_addressing is set in NVRAM
262 Rev. 3.13 Beta August 16, 2000 BN Qlogic
263 - Use new PCI DMA mapping APIs for 2.4.x kernel
264 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
265 - Added check of pci_enable_device to detect() for 2.3.x
266 - Use pci_resource_start() instead of
267 pdev->resource[0].start in detect() for 2.3.x
268 - Updated driver version
269 Rev. 3.11 July 14, 2000 BN Qlogic
270 - Updated SCSI Firmware to following versions:
273 - Updated driver version to 3.11
274 Rev. 3.10 June 23, 2000 BN Qlogic
275 - Added filtering of AMI SubSys Vendor ID devices
277 - DEBUG_QLA1280 undefined and new version BN Qlogic
278 Rev. 3.08b May 9, 2000 MD Dell
279 - Added logic to check against AMI subsystem vendor ID
280 Rev. 3.08 May 4, 2000 DG Qlogic
281 - Added logic to check for PCI subsystem ID.
282 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
283 - Updated SCSI Firmware to following versions:
286 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
287 - Internal revision; not released
288 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
289 - Edit correction for virt_to_bus and PROC.
290 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
291 - Merge changes from ia64 port.
292 Rev. 3.03 Mar 28, 2000 BN Qlogic
293 - Increase version to reflect new code drop with compile fix
294 of issue with inclusion of linux/spinlock for 2.3 kernels
295 Rev. 3.02 Mar 15, 2000 BN Qlogic
296 - Merge qla1280_proc_info from 2.10 code base
297 Rev. 3.01 Feb 10, 2000 BN Qlogic
298 - Corrected code to compile on a 2.2.x kernel.
299 Rev. 3.00 Jan 17, 2000 DG Qlogic
300 - Added 64-bit support.
301 Rev. 2.07 Nov 9, 1999 DG Qlogic
302 - Added new routine to set target parameters for ISP12160.
303 Rev. 2.06 Sept 10, 1999 DG Qlogic
304 - Added support for ISP12160 Ultra 3 chip.
305 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
306 - Modified code to remove errors generated when compiling with
307 Cygnus IA64 Compiler.
308 - Changed conversion of pointers to unsigned longs instead of integers.
309 - Changed type of I/O port variables from uint32_t to unsigned long.
310 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
311 - Changed sprintf and printk format specifiers for pointers to %p.
312 - Changed some int to long type casts where needed in sprintf & printk.
313 - Added l modifiers to sprintf and printk format specifiers for longs.
314 - Removed unused local variables.
315 Rev. 1.20 June 8, 1999 DG, Qlogic
316 Changes to support RedHat release 6.0 (kernel 2.2.5).
317 - Added SCSI exclusive access lock (io_request_lock) when accessing
319 - Added changes for the new LINUX interface template. Some new error
320 handling routines have been added to the template, but for now we
321 will use the old ones.
322 - Initial Beta Release.
323 *****************************************************************************/
326 #include <linux/config.h>
327 #include <linux/module.h>
329 #include <linux/version.h>
330 #include <linux/types.h>
331 #include <linux/string.h>
332 #include <linux/errno.h>
333 #include <linux/kernel.h>
334 #include <linux/ioport.h>
335 #include <linux/delay.h>
336 #include <linux/timer.h>
337 #include <linux/sched.h>
338 #include <linux/pci.h>
339 #include <linux/proc_fs.h>
340 #include <linux/stat.h>
341 #include <linux/slab.h>
342 #include <linux/pci_ids.h>
343 #include <linux/interrupt.h>
344 #include <linux/init.h>
348 #include <asm/byteorder.h>
349 #include <asm/processor.h>
350 #include <asm/types.h>
351 #include <asm/system.h>
353 #if LINUX_VERSION_CODE >= 0x020545
354 #include <scsi/scsi.h>
355 #include <scsi/scsi_cmnd.h>
356 #include <scsi/scsi_device.h>
357 #include <scsi/scsi_host.h>
358 #include <scsi/scsi_tcq.h>
361 #include <linux/blk.h>
363 #include <scsi/scsi_host.h>
367 #if LINUX_VERSION_CODE < 0x020407
368 #error "Kernels older than 2.4.7 are no longer supported"
373 * Compile time Options:
374 * 0 - Disable and 1 - Enable
376 #define DEBUG_QLA1280_INTR 0
377 #define DEBUG_PRINT_NVRAM 0
378 #define DEBUG_QLA1280 0
381 * The SGI VISWS is broken and doesn't support MMIO ;-(
383 #ifdef CONFIG_X86_VISWS
384 #define MEMORY_MAPPED_IO 0
386 #define MEMORY_MAPPED_IO 1
389 #define UNIQUE_FW_NAME
391 #include "ql12160_fw.h" /* ISP RISC codes */
392 #include "ql1280_fw.h"
398 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1080
399 #define PCI_DEVICE_ID_QLOGIC_ISP1080 0x1080
401 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1240
402 #define PCI_DEVICE_ID_QLOGIC_ISP1240 0x1240
404 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1280
405 #define PCI_DEVICE_ID_QLOGIC_ISP1280 0x1280
407 #ifndef PCI_DEVICE_ID_QLOGIC_ISP10160
408 #define PCI_DEVICE_ID_QLOGIC_ISP10160 0x1016
410 #ifndef PCI_DEVICE_ID_QLOGIC_ISP12160
411 #define PCI_DEVICE_ID_QLOGIC_ISP12160 0x1216
414 #ifndef PCI_VENDOR_ID_AMI
415 #define PCI_VENDOR_ID_AMI 0x101e
418 #ifndef BITS_PER_LONG
419 #error "BITS_PER_LONG not defined!"
421 #if (BITS_PER_LONG == 64) || defined CONFIG_HIGHMEM
422 #define QLA_64BIT_PTR 1
425 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
426 #include <asm/sn/pci/pciio.h>
427 /* Ugly hack needed for the virtual channel fix on SN2 */
428 extern int snia_pcibr_rrb_alloc(struct pci_dev
*pci_dev
,
429 int *count_vchan0
, int *count_vchan1
);
433 #define pci_dma_hi32(a) ((a >> 16) >> 16)
435 #define pci_dma_hi32(a) 0
437 #define pci_dma_lo32(a) (a & 0xffffffff)
439 #define NVRAM_DELAY() udelay(500) /* 2 microseconds */
441 #if LINUX_VERSION_CODE < 0x020500
442 #define HOST_LOCK &io_request_lock
443 #define irqreturn_t void
444 #define IRQ_RETVAL(foo)
445 #define MSG_ORDERED_TAG 1
447 #define DMA_BIDIRECTIONAL SCSI_DATA_UNKNOWN
448 #define DMA_TO_DEVICE SCSI_DATA_WRITE
449 #define DMA_FROM_DEVICE SCSI_DATA_READ
450 #define DMA_NONE SCSI_DATA_NONE
452 #ifndef HAVE_SECTOR_T
453 typedef unsigned int sector_t
;
457 scsi_adjust_queue_depth(struct scsi_device
*device
, int tag
, int depth
)
460 device
->tagged_queue
= tag
;
461 device
->current_tag
= 0;
463 device
->queue_depth
= depth
;
465 static inline struct Scsi_Host
*scsi_host_alloc(Scsi_Host_Template
*t
, size_t s
)
467 return scsi_register(t
, s
);
469 static inline void scsi_host_put(struct Scsi_Host
*h
)
474 #define HOST_LOCK ha->host->host_lock
476 #if LINUX_VERSION_CODE < 0x020600
477 #define DEV_SIMPLE_TAGS(device) device->tagged_queue
479 * Hack around that qla1280_remove_one is called from
480 * qla1280_release in 2.4
485 #define DEV_SIMPLE_TAGS(device) device->simple_tags
487 #if defined(__ia64__) && !defined(ia64_platform_is)
488 #define ia64_platform_is(foo) (!strcmp(x, platform_name))
492 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
493 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
494 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
495 #define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
496 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
499 static int qla1280_probe_one(struct pci_dev
*, const struct pci_device_id
*);
500 static void qla1280_remove_one(struct pci_dev
*);
503 * QLogic Driver Support Function Prototypes.
505 static void qla1280_done(struct scsi_qla_host
*);
506 #if LINUX_VERSION_CODE < 0x020545
507 static void qla1280_get_target_options(struct scsi_cmnd
*, struct scsi_qla_host
*);
509 static int qla1280_get_token(char *);
510 static int qla1280_setup(char *s
) __init
;
513 * QLogic ISP1280 Hardware Support Function Prototypes.
515 static int qla1280_load_firmware(struct scsi_qla_host
*);
516 static int qla1280_init_rings(struct scsi_qla_host
*);
517 static int qla1280_nvram_config(struct scsi_qla_host
*);
518 static int qla1280_mailbox_command(struct scsi_qla_host
*,
519 uint8_t, uint16_t *);
520 static int qla1280_bus_reset(struct scsi_qla_host
*, int);
521 static int qla1280_device_reset(struct scsi_qla_host
*, int, int);
522 static int qla1280_abort_device(struct scsi_qla_host
*, int, int, int);
523 static int qla1280_abort_command(struct scsi_qla_host
*, struct srb
*, int);
524 static int qla1280_abort_isp(struct scsi_qla_host
*);
526 static int qla1280_64bit_start_scsi(struct scsi_qla_host
*, struct srb
*);
528 static int qla1280_32bit_start_scsi(struct scsi_qla_host
*, struct srb
*);
530 static void qla1280_nv_write(struct scsi_qla_host
*, uint16_t);
531 static void qla1280_poll(struct scsi_qla_host
*);
532 static void qla1280_reset_adapter(struct scsi_qla_host
*);
533 static void qla1280_marker(struct scsi_qla_host
*, int, int, int, u8
);
534 static void qla1280_isp_cmd(struct scsi_qla_host
*);
535 static void qla1280_isr(struct scsi_qla_host
*, struct list_head
*);
536 static void qla1280_rst_aen(struct scsi_qla_host
*);
537 static void qla1280_status_entry(struct scsi_qla_host
*, struct response
*,
539 static void qla1280_error_entry(struct scsi_qla_host
*, struct response
*,
541 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host
*, uint32_t);
542 static uint16_t qla1280_nvram_request(struct scsi_qla_host
*, uint32_t);
543 static uint16_t qla1280_debounce_register(volatile uint16_t *);
544 static request_t
*qla1280_req_pkt(struct scsi_qla_host
*);
545 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host
*,
547 static void qla1280_get_target_parameters(struct scsi_qla_host
*,
548 struct scsi_device
*);
549 static int qla1280_set_target_parameters(struct scsi_qla_host
*, int, int);
552 static struct qla_driver_setup driver_setup __initdata
;
555 * convert scsi data direction to request_t control flags
557 static inline uint16_t
558 qla1280_data_direction(struct scsi_cmnd
*cmnd
)
560 switch(cmnd
->sc_data_direction
) {
561 case DMA_FROM_DEVICE
:
565 case DMA_BIDIRECTIONAL
:
566 return BIT_5
| BIT_6
;
568 * We could BUG() on default here if one of the four cases aren't
569 * met, but then again if we receive something like that from the
570 * SCSI layer we have more serious problems. This shuts up GCC.
579 static void __qla1280_print_scsi_cmd(struct scsi_cmnd
* cmd
);
580 static void __qla1280_dump_buffer(char *, int);
585 * insmod needs to find the variable and make it point to something
588 static char *qla1280
;
590 /* insmod qla1280 options=verbose" */
591 MODULE_PARM(qla1280
, "s");
593 __setup("qla1280=", qla1280_setup
);
598 * We use the scsi_pointer structure that's included with each scsi_command
599 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
600 * bigger than a scsi_pointer.
603 #define CMD_SP(Cmnd) &Cmnd->SCp
604 #define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
605 #define CMD_CDBP(Cmnd) Cmnd->cmnd
606 #define CMD_SNSP(Cmnd) Cmnd->sense_buffer
607 #define CMD_SNSLEN(Cmnd) sizeof(Cmnd->sense_buffer)
608 #define CMD_RESULT(Cmnd) Cmnd->result
609 #define CMD_HANDLE(Cmnd) Cmnd->host_scribble
610 #if LINUX_VERSION_CODE < 0x020545
611 #define CMD_REQUEST(Cmnd) Cmnd->request.cmd
613 #define CMD_REQUEST(Cmnd) Cmnd->request->cmd
616 #define CMD_HOST(Cmnd) Cmnd->device->host
617 #define SCSI_BUS_32(Cmnd) Cmnd->device->channel
618 #define SCSI_TCN_32(Cmnd) Cmnd->device->id
619 #define SCSI_LUN_32(Cmnd) Cmnd->device->lun
622 /*****************************************/
623 /* ISP Boards supported by this driver */
624 /*****************************************/
627 unsigned char name
[9]; /* Board ID String */
628 int numPorts
; /* Number of SCSI ports */
629 unsigned short *fwcode
; /* pointer to FW array */
630 unsigned short *fwlen
; /* number of words in array */
631 unsigned short *fwstart
; /* start address for F/W */
632 unsigned char *fwver
; /* Ptr to F/W version array */
635 /* NOTE: qla1280_pci_tbl and ql1280_board_tbl must be in the same order */
636 static struct pci_device_id qla1280_pci_tbl
[] = {
637 {PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP12160
,
638 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 0},
639 {PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP1080
,
640 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 1},
641 {PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP1240
,
642 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 2},
643 {PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP1280
,
644 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 3},
645 {PCI_VENDOR_ID_QLOGIC
, PCI_DEVICE_ID_QLOGIC_ISP10160
,
646 PCI_ANY_ID
, PCI_ANY_ID
, 0, 0, 4},
649 MODULE_DEVICE_TABLE(pci
, qla1280_pci_tbl
);
651 static struct qla_boards ql1280_board_tbl
[] = {
652 /* Name , Number of ports, FW details */
653 {"QLA12160", 2, &fw12160i_code01
[0], &fw12160i_length01
,
654 &fw12160i_addr01
, &fw12160i_version_str
[0]},
655 {"QLA1080", 1, &fw1280ei_code01
[0], &fw1280ei_length01
,
656 &fw1280ei_addr01
, &fw1280ei_version_str
[0]},
657 {"QLA1240", 2, &fw1280ei_code01
[0], &fw1280ei_length01
,
658 &fw1280ei_addr01
, &fw1280ei_version_str
[0]},
659 {"QLA1280", 2, &fw1280ei_code01
[0], &fw1280ei_length01
,
660 &fw1280ei_addr01
, &fw1280ei_version_str
[0]},
661 {"QLA10160", 1, &fw12160i_code01
[0], &fw12160i_length01
,
662 &fw12160i_addr01
, &fw12160i_version_str
[0]},
666 static int qla1280_verbose
= 1;
667 static int qla1280_buffer_size
;
668 static char *qla1280_buffer
;
671 static int ql_debug_level
= 1;
672 #define dprintk(level, format, a...) \
673 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
674 #define qla1280_dump_buffer(level, buf, size) \
675 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
676 #define qla1280_print_scsi_cmd(level, cmd) \
677 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
679 #define ql_debug_level 0
680 #define dprintk(level, format, a...) do{}while(0)
681 #define qla1280_dump_buffer(a, b, c) do{}while(0)
682 #define qla1280_print_scsi_cmd(a, b) do{}while(0)
685 #define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
686 #define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
687 #define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
688 #define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
691 /*************************************************************************
695 * Return information to handle /proc support for the driver.
697 * buffer - ptrs to a page buffer
700 *************************************************************************/
701 #define PROC_BUF &qla1280_buffer[len]
703 static int qla1280_proc_info(struct Scsi_Host
*host
, char *buffer
,
704 char **start
, off_t offset
, int length
, int inout
)
706 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
707 struct qla_boards
*bdp
= &ql1280_board_tbl
[ha
->devnum
];
715 * if our old buffer is the right size use it otherwise
716 * allocate a new one.
718 if (qla1280_buffer_size
!= PAGE_SIZE
) {
719 /* deallocate this buffer and get a new one */
720 if (qla1280_buffer
!= NULL
) {
721 free_page((unsigned long)qla1280_buffer
);
722 qla1280_buffer_size
= 0;
724 qla1280_buffer
= (char *)get_zeroed_page(GFP_KERNEL
);
726 if (qla1280_buffer
== NULL
) {
727 size
= sprintf(buffer
, "qla1280 - kmalloc error at line %d\n",
731 /* save the size of our buffer */
732 qla1280_buffer_size
= PAGE_SIZE
;
734 /* 3.20 clear the buffer we use for proc display */
735 memset(qla1280_buffer
, 0, PAGE_SIZE
);
737 /* start building the print buffer */
738 size
= sprintf(PROC_BUF
,
739 "QLogic PCI to SCSI Adapter for ISP 1280/12160:\n"
740 " Firmware version: %2d.%02d.%02d, Driver version %s\n",
741 bdp
->fwver
[0], bdp
->fwver
[1], bdp
->fwver
[2],
746 size
= sprintf(PROC_BUF
, "SCSI Host Adapter Information: %s\n",
749 size
= sprintf(PROC_BUF
, "Request Queue count= 0x%x, Response "
750 "Queue count= 0x%x\n",
751 REQUEST_ENTRY_CNT
, RESPONSE_ENTRY_CNT
);
753 size
= sprintf(PROC_BUF
, "Number of pending commands = 0x%lx\n",
756 size
= sprintf(PROC_BUF
, "Number of free request entries = %d\n",
759 size
= sprintf(PROC_BUF
, "\n"); /* 1 */
762 if (len
>= qla1280_buffer_size
) {
764 "qla1280: Overflow buffer in qla1280_proc.c\n");
767 if (offset
> len
- 1) {
768 free_page((unsigned long) qla1280_buffer
);
769 qla1280_buffer
= NULL
;
770 qla1280_buffer_size
= length
= 0;
773 *start
= &qla1280_buffer
[offset
]; /* Start of wanted data */
774 if (len
- offset
< length
) {
775 length
= len
- offset
;
782 static int qla1280_read_nvram(struct scsi_qla_host
*ha
)
789 ENTER("qla1280_read_nvram");
791 if (driver_setup
.no_nvram
)
794 printk(KERN_INFO
"scsi(%ld): Reading NVRAM\n", ha
->host_no
);
796 wptr
= (uint16_t *)&ha
->nvram
;
799 for (cnt
= 0; cnt
< 3; cnt
++) {
800 *wptr
= qla1280_get_nvram_word(ha
, cnt
);
801 chksum
+= *wptr
& 0xff;
802 chksum
+= (*wptr
>> 8) & 0xff;
806 if (nv
->id0
!= 'I' || nv
->id1
!= 'S' ||
807 nv
->id2
!= 'P' || nv
->id3
!= ' ' || nv
->version
< 1) {
808 dprintk(2, "Invalid nvram ID or version!\n");
811 for (; cnt
< sizeof(struct nvram
); cnt
++) {
812 *wptr
= qla1280_get_nvram_word(ha
, cnt
);
813 chksum
+= *wptr
& 0xff;
814 chksum
+= (*wptr
>> 8) & 0xff;
819 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
820 " version %i\n", nv
->id0
, nv
->id1
, nv
->id2
, nv
->id3
,
825 if (!driver_setup
.no_nvram
)
826 printk(KERN_WARNING
"scsi(%ld): Unable to identify or "
827 "validate NVRAM checksum, using default "
828 "settings\n", ha
->host_no
);
833 /* The firmware interface is, um, interesting, in that the
834 * actual firmware image on the chip is little endian, thus,
835 * the process of taking that image to the CPU would end up
836 * little endian. However, the firmare interface requires it
837 * to be read a word (two bytes) at a time.
839 * The net result of this would be that the word (and
840 * doubleword) quantites in the firmware would be correct, but
841 * the bytes would be pairwise reversed. Since most of the
842 * firmware quantites are, in fact, bytes, we do an extra
843 * le16_to_cpu() in the firmware read routine.
845 * The upshot of all this is that the bytes in the firmware
846 * are in the correct places, but the 16 and 32 bit quantites
847 * are still in little endian format. We fix that up below by
848 * doing extra reverses on them */
849 nv
->isp_parameter
= cpu_to_le16(nv
->isp_parameter
);
850 nv
->firmware_feature
.w
= cpu_to_le16(nv
->firmware_feature
.w
);
851 for(i
= 0; i
< MAX_BUSES
; i
++) {
852 nv
->bus
[i
].selection_timeout
= cpu_to_le16(nv
->bus
[i
].selection_timeout
);
853 nv
->bus
[i
].max_queue_depth
= cpu_to_le16(nv
->bus
[i
].max_queue_depth
);
855 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
856 LEAVE("qla1280_read_nvram");
861 /**************************************************************************
863 * Return a string describing the driver.
864 **************************************************************************/
866 qla1280_info(struct Scsi_Host
*host
)
868 static char qla1280_scsi_name_buffer
[125];
870 struct scsi_qla_host
*ha
;
871 struct qla_boards
*bdp
;
873 bp
= &qla1280_scsi_name_buffer
[0];
874 ha
= (struct scsi_qla_host
*)host
->hostdata
;
875 bdp
= &ql1280_board_tbl
[ha
->devnum
];
876 memset(bp
, 0, sizeof(qla1280_scsi_name_buffer
));
879 "QLogic %s PCI to SCSI Host Adapter\n"
880 " Firmware version: %2d.%02d.%02d, Driver version %s",
881 &bdp
->name
[0], bdp
->fwver
[0], bdp
->fwver
[1], bdp
->fwver
[2],
886 /**************************************************************************
887 * qla1200_queuecommand
888 * Queue a command to the controller.
891 * The mid-level driver tries to ensures that queuecommand never gets invoked
892 * concurrently with itself or the interrupt handler (although the
893 * interrupt handler may call this routine as part of request-completion
894 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
895 * context which is a big NO! NO!.
896 **************************************************************************/
898 qla1280_queuecommand(struct scsi_cmnd
*cmd
, void (*fn
)(struct scsi_cmnd
*))
900 struct Scsi_Host
*host
= cmd
->device
->host
;
901 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
902 struct srb
*sp
= (struct srb
*)&cmd
->SCp
;
909 qla1280_print_scsi_cmd(5, cmd
);
913 * Using 64 bit commands if the PCI bridge doesn't support it is a
914 * bit wasteful, however this should really only happen if one's
915 * PCI controller is completely broken, like the BCM1250. For
916 * sane hardware this is not an issue.
918 status
= qla1280_64bit_start_scsi(ha
, sp
);
920 status
= qla1280_32bit_start_scsi(ha
, sp
);
934 /* timer action for error action processor */
935 static void qla1280_error_wait_timeout(unsigned long __data
)
937 struct scsi_cmnd
*cmd
= (struct scsi_cmnd
*)__data
;
938 struct srb
*sp
= (struct srb
*)CMD_SP(cmd
);
943 static void qla1280_mailbox_timeout(unsigned long __data
)
945 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)__data
;
946 struct device_reg
*reg
;
949 ha
->mailbox_out
[0] = RD_REG_WORD(®
->mailbox0
);
950 printk(KERN_ERR
"scsi(%ld): mailbox timed out, mailbox0 %04x, "
951 "ictrl %04x, istatus %04x\n", ha
->host_no
, ha
->mailbox_out
[0],
952 RD_REG_WORD(®
->ictrl
), RD_REG_WORD(®
->istatus
));
953 complete(ha
->mailbox_wait
);
956 /**************************************************************************
957 * qla1200_error_action
958 * The function will attempt to perform a specified error action and
959 * wait for the results (or time out).
962 * cmd = Linux SCSI command packet of the command that cause the
964 * action = error action to take (see action_t)
970 * Resetting the bus always succeeds - is has to, otherwise the
971 * kernel will panic! Try a surgical technique - sending a BUS
972 * DEVICE RESET message - on the offending target before pulling
973 * the SCSI bus reset line.
974 **************************************************************************/
976 qla1280_error_action(struct scsi_cmnd
*cmd
, enum action action
)
978 struct scsi_qla_host
*ha
;
979 int bus
, target
, lun
;
982 unsigned char *handle
;
984 DECLARE_COMPLETION(wait
);
985 struct timer_list timer
;
987 ha
= (struct scsi_qla_host
*)(CMD_HOST(cmd
)->hostdata
);
989 dprintk(4, "error_action %i, istatus 0x%04x\n", action
,
990 RD_REG_WORD(&ha
->iobase
->istatus
));
992 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
993 RD_REG_WORD(&ha
->iobase
->host_cmd
),
994 RD_REG_WORD(&ha
->iobase
->ictrl
), jiffies
);
996 ENTER("qla1280_error_action");
998 printk(KERN_INFO
"scsi(%li): Resetting Cmnd=0x%p, "
999 "Handle=0x%p, action=0x%x\n",
1000 ha
->host_no
, cmd
, CMD_HANDLE(cmd
), action
);
1003 printk(KERN_WARNING
"(scsi?:?:?:?) Reset called with NULL "
1004 "si_Cmnd pointer, failing.\n");
1005 LEAVE("qla1280_error_action");
1009 ha
= (struct scsi_qla_host
*)cmd
->device
->host
->hostdata
;
1010 sp
= (struct srb
*)CMD_SP(cmd
);
1011 handle
= CMD_HANDLE(cmd
);
1013 /* Check for pending interrupts. */
1014 data
= qla1280_debounce_register(&ha
->iobase
->istatus
);
1016 * The io_request_lock is held when the reset handler is called, hence
1017 * the interrupt handler cannot be running in parallel as it also
1018 * grabs the lock. /Jes
1020 if (data
& RISC_INT
)
1021 qla1280_isr(ha
, &ha
->done_q
);
1024 * Determine the suggested action that the mid-level driver wants
1027 if (handle
== (unsigned char *)INVALID_HANDLE
|| handle
== NULL
) {
1028 if(action
== ABORT_COMMAND
) {
1029 /* we never got this command */
1030 printk(KERN_INFO
"qla1280: Aborting a NULL handle\n");
1031 return SUCCESS
; /* no action - we don't have command */
1037 bus
= SCSI_BUS_32(cmd
);
1038 target
= SCSI_TCN_32(cmd
);
1039 lun
= SCSI_LUN_32(cmd
);
1041 /* Overloading result. Here it means the success or fail of the
1042 * *issue* of the action. When we return from the routine, it must
1043 * mean the actual success or fail of the action */
1050 if ((sp
->flags
& SRB_ABORT_PENDING
)) {
1052 "scsi(): Command has a pending abort "
1053 "message - ABORT_PENDING.\n");
1054 /* This should technically be impossible since we
1055 * now wait for abort completion */
1059 for (i
= 0; i
< MAX_OUTSTANDING_COMMANDS
; i
++) {
1060 if (sp
== ha
->outstanding_cmds
[i
]) {
1061 dprintk(1, "qla1280: RISC aborting command\n");
1062 if (qla1280_abort_command(ha
, sp
, i
) == 0)
1066 * Since we don't know what might
1067 * have happend to the command, it
1068 * is unsafe to remove it from the
1069 * device's queue at this point.
1070 * Wait and let the escalation
1071 * process take care of it.
1074 "scsi(%li:%i:%i:%i): Unable"
1075 " to abort command!\n",
1076 ha
->host_no
, bus
, target
, lun
);
1083 ha
->flags
.in_reset
= 1;
1084 if (qla1280_verbose
)
1086 "scsi(%ld:%d:%d:%d): Queueing abort device "
1087 "command.\n", ha
->host_no
, bus
, target
, lun
);
1088 if (qla1280_abort_device(ha
, bus
, target
, lun
) == 0)
1093 if (qla1280_verbose
)
1095 "scsi(%ld:%d:%d:%d): Queueing device reset "
1096 "command.\n", ha
->host_no
, bus
, target
, lun
);
1097 ha
->flags
.in_reset
= 1;
1098 if (qla1280_device_reset(ha
, bus
, target
) == 0)
1103 if (qla1280_verbose
)
1104 printk(KERN_INFO
"qla1280(%ld:%d): Issuing BUS "
1105 "DEVICE RESET\n", ha
->host_no
, bus
);
1106 ha
->flags
.in_reset
= 1;
1107 if (qla1280_bus_reset(ha
, bus
== 0))
1114 if (qla1280_verbose
) {
1116 "scsi(%ld): Issued ADAPTER RESET\n",
1118 printk(KERN_INFO
"scsi(%ld): I/O processing will "
1119 "continue automatically\n", ha
->host_no
);
1121 ha
->flags
.reset_active
= 1;
1123 * We restarted all of the commands automatically, so the
1124 * mid-level code can expect completions momentitarily.
1126 if (qla1280_abort_isp(ha
) == 0)
1129 ha
->flags
.reset_active
= 0;
1132 if (!list_empty(&ha
->done_q
))
1134 ha
->flags
.in_reset
= 0;
1136 /* If we didn't manage to issue the action, or we have no
1137 * command to wait for, exit here */
1138 if (result
== FAILED
|| handle
== NULL
||
1139 handle
== (unsigned char *)INVALID_HANDLE
) {
1141 * Clear completion queue to avoid qla1280_done() trying
1142 * to complete the command at a later stage after we
1143 * have exited the current context
1149 /* set up a timer just in case we're really jammed */
1151 timer
.expires
= jiffies
+ 4*HZ
;
1152 timer
.data
= (unsigned long)cmd
;
1153 timer
.function
= qla1280_error_wait_timeout
;
1156 /* wait for the action to complete (or the timer to expire) */
1157 spin_unlock_irq(HOST_LOCK
);
1158 wait_for_completion(&wait
);
1159 del_timer_sync(&timer
);
1160 spin_lock_irq(HOST_LOCK
);
1163 /* the only action we might get a fail for is abort */
1164 if (action
== ABORT_COMMAND
) {
1165 if(sp
->flags
& SRB_ABORTED
)
1172 dprintk(1, "RESET returning %d\n", result
);
1174 LEAVE("qla1280_error_action");
1178 /**************************************************************************
1180 * Abort the specified SCSI command(s).
1181 **************************************************************************/
1183 qla1280_eh_abort(struct scsi_cmnd
* cmd
)
1185 return qla1280_error_action(cmd
, ABORT_COMMAND
);
1188 /**************************************************************************
1189 * qla1280_device_reset
1190 * Reset the specified SCSI device
1191 **************************************************************************/
1193 qla1280_eh_device_reset(struct scsi_cmnd
*cmd
)
1195 return qla1280_error_action(cmd
, DEVICE_RESET
);
1198 /**************************************************************************
1200 * Reset the specified bus.
1201 **************************************************************************/
1203 qla1280_eh_bus_reset(struct scsi_cmnd
*cmd
)
1205 return qla1280_error_action(cmd
, BUS_RESET
);
1208 /**************************************************************************
1209 * qla1280_adapter_reset
1210 * Reset the specified adapter (both channels)
1211 **************************************************************************/
1213 qla1280_eh_adapter_reset(struct scsi_cmnd
*cmd
)
1215 return qla1280_error_action(cmd
, ADAPTER_RESET
);
1219 qla1280_biosparam(struct scsi_device
*sdev
, struct block_device
*bdev
,
1220 sector_t capacity
, int geom
[])
1222 int heads
, sectors
, cylinders
;
1226 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
1227 if (cylinders
> 1024) {
1230 cylinders
= (unsigned long)capacity
/ (heads
* sectors
);
1231 /* if (cylinders > 1023)
1232 cylinders = 1023; */
1237 geom
[2] = cylinders
;
1242 #if LINUX_VERSION_CODE < 0x020600
1244 qla1280_detect(Scsi_Host_Template
*template)
1246 struct pci_device_id
*id
= &qla1280_pci_tbl
[0];
1247 struct pci_dev
*pdev
= NULL
;
1250 if (sizeof(struct srb
) > sizeof(Scsi_Pointer
)) {
1252 "qla1280: struct srb too big, aborting\n");
1256 if ((DMA_BIDIRECTIONAL
!= PCI_DMA_BIDIRECTIONAL
) ||
1257 (DMA_TO_DEVICE
!= PCI_DMA_TODEVICE
) ||
1258 (DMA_FROM_DEVICE
!= PCI_DMA_FROMDEVICE
) ||
1259 (DMA_NONE
!= PCI_DMA_NONE
)) {
1261 "qla1280: dma direction bits don't match\n");
1267 * If we are called as a module, the qla1280 pointer may not be null
1268 * and it would point to our bootup string, just like on the lilo
1269 * command line. IF not NULL, then process this config string with
1273 * To add options at boot time add a line to your lilo.conf file like:
1274 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
1275 * which will result in the first four devices on the first two
1276 * controllers being set to a tagged queue depth of 32.
1279 qla1280_setup(qla1280
);
1282 /* First Initialize QLA12160 on PCI Bus 1 Dev 2 */
1283 while ((pdev
= pci_find_device(id
->vendor
, id
->device
, pdev
))) {
1284 if (pdev
->bus
->number
== 1 && PCI_SLOT(pdev
->devfn
) == 2) {
1285 if (!qla1280_probe_one(pdev
, id
))
1291 /* Try and find each different type of adapter we support */
1292 for (id
= &qla1280_pci_tbl
[0]; id
->device
; id
++) {
1293 while ((pdev
= pci_find_device(id
->vendor
, id
->device
, pdev
))) {
1295 * skip QLA12160 already initialized on
1296 * PCI Bus 1 Dev 2 since we already initialized
1299 if (id
->device
== PCI_DEVICE_ID_QLOGIC_ISP12160
&&
1300 pdev
->bus
->number
== 1 &&
1301 PCI_SLOT(pdev
->devfn
) == 2)
1304 if (!qla1280_probe_one(pdev
, id
))
1313 * This looks a bit ugly as we could just pass down host to
1314 * qla1280_remove_one, but I want to keep qla1280_release purely a wrapper
1315 * around pci_driver::remove as used from 2.6 onwards.
1318 qla1280_release(struct Scsi_Host
*host
)
1320 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
1322 qla1280_remove_one(ha
->pdev
);
1327 qla1280_biosparam_old(Disk
* disk
, kdev_t dev
, int geom
[])
1329 return qla1280_biosparam(disk
->device
, NULL
, disk
->capacity
, geom
);
1333 qla1280_proc_info_old(char *buffer
, char **start
, off_t offset
, int length
,
1334 int hostno
, int inout
)
1336 struct Scsi_Host
*host
;
1338 for (host
= scsi_hostlist
; host
; host
= host
->next
) {
1339 if (host
->host_no
== hostno
) {
1340 return qla1280_proc_info(host
, buffer
, start
,
1341 offset
, length
, inout
);
1349 /**************************************************************************
1350 * qla1280_intr_handler
1351 * Handles the H/W interrupt
1352 **************************************************************************/
1354 qla1280_intr_handler(int irq
, void *dev_id
, struct pt_regs
*regs
)
1356 struct scsi_qla_host
*ha
;
1357 struct device_reg
*reg
;
1361 ENTER_INTR ("qla1280_intr_handler");
1362 ha
= (struct scsi_qla_host
*)dev_id
;
1364 spin_lock(HOST_LOCK
);
1369 WRT_REG_WORD(®
->ictrl
, 0); /* disable our interrupt. */
1371 data
= qla1280_debounce_register(®
->istatus
);
1372 /* Check for pending interrupts. */
1373 if (data
& RISC_INT
) {
1374 qla1280_isr(ha
, &ha
->done_q
);
1377 if (!list_empty(&ha
->done_q
))
1380 spin_unlock(HOST_LOCK
);
1382 /* enable our interrupt. */
1383 WRT_REG_WORD(®
->ictrl
, (ISP_EN_INT
| ISP_EN_RISC
));
1385 LEAVE_INTR("qla1280_intr_handler");
1386 return IRQ_RETVAL(handled
);
1391 qla1280_set_target_parameters(struct scsi_qla_host
*ha
, int bus
, int target
)
1394 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1400 mr
= BIT_3
| BIT_2
| BIT_1
| BIT_0
;
1402 /* Set Target Parameters. */
1403 mb
[0] = MBC_SET_TARGET_PARAMETERS
;
1404 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
1407 mb
[2] = (nv
->bus
[bus
].target
[target
].parameter
.c
<< 8);
1409 if (IS_ISP1x160(ha
)) {
1410 mb
[2] |= nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
<< 5;
1411 mb
[3] = (nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
<< 8) |
1412 nv
->bus
[bus
].target
[target
].sync_period
;
1413 mb
[6] = (nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_options
<< 8) |
1414 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_bus_width
;
1417 mb
[3] = (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
<< 8) |
1418 nv
->bus
[bus
].target
[target
].sync_period
;
1421 status
= qla1280_mailbox_command(ha
, mr
, &mb
[0]);
1424 printk(KERN_WARNING
"scsi(%ld:%i:%i): "
1425 "qla1280_set_target_parameters() failed\n",
1426 ha
->host_no
, bus
, target
);
1431 /**************************************************************************
1432 * qla1280_slave_configure
1435 * Determines the queue depth for a given device. There are two ways
1436 * a queue depth can be obtained for a tagged queueing device. One
1437 * way is the default queue depth which is determined by whether
1438 * If it is defined, then it is used
1439 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1440 * default queue depth (dependent on the number of hardware SCBs).
1441 **************************************************************************/
1443 qla1280_slave_configure(struct scsi_device
*device
)
1445 struct scsi_qla_host
*ha
;
1446 int default_depth
= 3;
1447 int bus
= device
->channel
;
1448 int target
= device
->id
;
1451 unsigned long flags
;
1453 ha
= (struct scsi_qla_host
*)device
->host
->hostdata
;
1456 if (qla1280_check_for_dead_scsi_bus(ha
, bus
))
1459 if (device
->tagged_supported
&&
1460 (ha
->bus_settings
[bus
].qtag_enables
& (BIT_0
<< target
))) {
1461 scsi_adjust_queue_depth(device
, MSG_ORDERED_TAG
,
1462 ha
->bus_settings
[bus
].hiwat
);
1464 scsi_adjust_queue_depth(device
, 0, default_depth
);
1467 #if LINUX_VERSION_CODE > 0x020500
1468 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= device
->sdtr
;
1469 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= device
->wdtr
;
1470 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= device
->ppr
;
1473 if (driver_setup
.no_sync
||
1474 (driver_setup
.sync_mask
&&
1475 (~driver_setup
.sync_mask
& (1 << target
))))
1476 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 0;
1477 if (driver_setup
.no_wide
||
1478 (driver_setup
.wide_mask
&&
1479 (~driver_setup
.wide_mask
& (1 << target
))))
1480 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 0;
1481 if (IS_ISP1x160(ha
)) {
1482 if (driver_setup
.no_ppr
||
1483 (driver_setup
.ppr_mask
&&
1484 (~driver_setup
.ppr_mask
& (1 << target
))))
1485 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 0;
1488 spin_lock_irqsave(HOST_LOCK
, flags
);
1489 if (nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
)
1490 status
= qla1280_set_target_parameters(ha
, bus
, target
);
1491 qla1280_get_target_parameters(ha
, device
);
1492 spin_unlock_irqrestore(HOST_LOCK
, flags
);
1496 #if LINUX_VERSION_CODE < 0x020545
1497 /**************************************************************************
1498 * qla1280_select_queue_depth
1500 * Sets the queue depth for each SCSI device hanging off the input
1501 * host adapter. We use a queue depth of 2 for devices that do not
1502 * support tagged queueing.
1503 **************************************************************************/
1505 qla1280_select_queue_depth(struct Scsi_Host
*host
, struct scsi_device
*sdev_q
)
1507 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
1508 struct scsi_device
*sdev
;
1510 ENTER("qla1280_select_queue_depth");
1511 for (sdev
= sdev_q
; sdev
; sdev
= sdev
->next
)
1512 if (sdev
->host
== host
)
1513 qla1280_slave_configure(sdev
);
1516 qla1280_check_for_dead_scsi_bus(ha
, sdev_q
->channel
);
1517 LEAVE("qla1280_select_queue_depth");
1523 * Process completed commands.
1526 * ha = adapter block pointer.
1527 * done_q = done queue.
1530 qla1280_done(struct scsi_qla_host
*ha
)
1533 struct list_head
*done_q
;
1534 int bus
, target
, lun
;
1535 struct scsi_cmnd
*cmd
;
1537 ENTER("qla1280_done");
1539 done_q
= &ha
->done_q
;
1541 while (!list_empty(done_q
)) {
1542 sp
= list_entry(done_q
->next
, struct srb
, list
);
1544 list_del(&sp
->list
);
1547 bus
= SCSI_BUS_32(cmd
);
1548 target
= SCSI_TCN_32(cmd
);
1549 lun
= SCSI_LUN_32(cmd
);
1551 switch ((CMD_RESULT(cmd
) >> 16)) {
1553 /* Issue marker command. */
1554 qla1280_marker(ha
, bus
, target
, 0, MK_SYNC_ID
);
1557 sp
->flags
&= ~SRB_ABORT_PENDING
;
1558 sp
->flags
|= SRB_ABORTED
;
1559 if (sp
->flags
& SRB_TIMEOUT
)
1560 CMD_RESULT(sp
->cmd
) = DID_TIME_OUT
<< 16;
1566 /* Release memory used for this I/O */
1568 dprintk(3, "S/G unmap_sg cmd=%p\n", cmd
);
1570 pci_unmap_sg(ha
->pdev
, cmd
->request_buffer
,
1571 cmd
->use_sg
, cmd
->sc_data_direction
);
1572 } else if (cmd
->request_bufflen
) {
1573 /*dprintk(1, "No S/G unmap_single cmd=%x saved_dma_handle=%lx\n",
1574 cmd, sp->saved_dma_handle); */
1576 pci_unmap_page(ha
->pdev
, sp
->saved_dma_handle
,
1577 cmd
->request_bufflen
, cmd
->sc_data_direction
);
1580 /* Call the mid-level driver interrupt handler */
1581 CMD_HANDLE(sp
->cmd
) = (unsigned char *)INVALID_HANDLE
;
1584 #if LINUX_VERSION_CODE < 0x020500
1585 if (cmd
->cmnd
[0] == INQUIRY
)
1586 qla1280_get_target_options(cmd
, ha
);
1588 (*(cmd
)->scsi_done
)(cmd
);
1590 if(sp
->wait
!= NULL
)
1593 LEAVE("qla1280_done");
1597 * Translates a ISP error to a Linux SCSI error
1600 qla1280_return_status(struct response
* sts
, struct scsi_cmnd
*cp
)
1602 int host_status
= DID_ERROR
;
1603 uint16_t comp_status
= le16_to_cpu(sts
->comp_status
);
1604 uint16_t state_flags
= le16_to_cpu(sts
->state_flags
);
1605 uint16_t residual_length
= le16_to_cpu(sts
->residual_length
);
1606 uint16_t scsi_status
= le16_to_cpu(sts
->scsi_status
);
1607 #if DEBUG_QLA1280_INTR
1608 static char *reason
[] = {
1620 #endif /* DEBUG_QLA1280_INTR */
1622 ENTER("qla1280_return_status");
1624 #if DEBUG_QLA1280_INTR
1626 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1631 switch (comp_status
) {
1633 host_status
= DID_OK
;
1637 if (!(state_flags
& SF_GOT_BUS
))
1638 host_status
= DID_NO_CONNECT
;
1639 else if (!(state_flags
& SF_GOT_TARGET
))
1640 host_status
= DID_BAD_TARGET
;
1641 else if (!(state_flags
& SF_SENT_CDB
))
1642 host_status
= DID_ERROR
;
1643 else if (!(state_flags
& SF_TRANSFERRED_DATA
))
1644 host_status
= DID_ERROR
;
1645 else if (!(state_flags
& SF_GOT_STATUS
))
1646 host_status
= DID_ERROR
;
1647 else if (!(state_flags
& SF_GOT_SENSE
))
1648 host_status
= DID_ERROR
;
1652 host_status
= DID_RESET
;
1656 host_status
= DID_ABORT
;
1660 host_status
= DID_TIME_OUT
;
1663 case CS_DATA_OVERRUN
:
1664 dprintk(2, "Data overrun 0x%x\n", residual_length
);
1665 dprintk(2, "qla1280_isr: response packet data\n");
1666 qla1280_dump_buffer(2, (char *)sts
, RESPONSE_ENTRY_SIZE
);
1667 host_status
= DID_ERROR
;
1670 case CS_DATA_UNDERRUN
:
1671 if ((cp
->request_bufflen
- residual_length
) <
1674 "scsi: Underflow detected - retrying "
1676 host_status
= DID_ERROR
;
1678 host_status
= DID_OK
;
1682 host_status
= DID_ERROR
;
1686 #if DEBUG_QLA1280_INTR
1687 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1688 reason
[host_status
], scsi_status
);
1691 LEAVE("qla1280_return_status");
1693 return (scsi_status
& 0xff) | (host_status
<< 16);
1696 /****************************************************************************/
1697 /* QLogic ISP1280 Hardware Support Functions. */
1698 /****************************************************************************/
1701 * qla2100_enable_intrs
1702 * qla2100_disable_intrs
1705 * ha = adapter block pointer.
1711 qla1280_enable_intrs(struct scsi_qla_host
*ha
)
1713 struct device_reg
*reg
;
1716 /* enable risc and host interrupts */
1717 WRT_REG_WORD(®
->ictrl
, (ISP_EN_INT
| ISP_EN_RISC
));
1718 RD_REG_WORD(®
->ictrl
); /* PCI Posted Write flush */
1719 ha
->flags
.ints_enabled
= 1;
1723 qla1280_disable_intrs(struct scsi_qla_host
*ha
)
1725 struct device_reg
*reg
;
1728 /* disable risc and host interrupts */
1729 WRT_REG_WORD(®
->ictrl
, 0);
1730 RD_REG_WORD(®
->ictrl
); /* PCI Posted Write flush */
1731 ha
->flags
.ints_enabled
= 0;
1735 * qla1280_initialize_adapter
1739 * ha = adapter block pointer.
1744 static int __devinit
1745 qla1280_initialize_adapter(struct scsi_qla_host
*ha
)
1747 struct device_reg
*reg
;
1750 #if LINUX_VERSION_CODE > 0x020500
1751 unsigned long flags
;
1754 ENTER("qla1280_initialize_adapter");
1756 /* Clear adapter flags. */
1757 ha
->flags
.online
= 0;
1758 ha
->flags
.disable_host_adapter
= 0;
1759 ha
->flags
.reset_active
= 0;
1760 ha
->flags
.abort_isp_active
= 0;
1762 ha
->flags
.ints_enabled
= 0;
1763 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1764 if (ia64_platform_is("sn2")) {
1770 printk(KERN_INFO
"scsi(%li): Enabling SN2 PCI DMA "
1771 "dual channel lockup workaround\n", ha
->host_no
);
1772 if ((c
= snia_pcibr_rrb_alloc(ha
->pdev
, &count1
, &count2
)) < 0)
1773 printk(KERN_ERR
"scsi(%li): Unable to allocate SN2 "
1774 "virtual DMA channels\n", ha
->host_no
);
1776 ha
->flags
.use_pci_vchannel
= 1;
1778 driver_setup
.no_nvram
= 1;
1782 dprintk(1, "Configure PCI space for adapter...\n");
1786 /* Insure mailbox registers are free. */
1787 WRT_REG_WORD(®
->semaphore
, 0);
1788 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
1789 WRT_REG_WORD(®
->host_cmd
, HC_CLR_HOST_INT
);
1790 RD_REG_WORD(®
->host_cmd
);
1792 if (qla1280_read_nvram(ha
)) {
1793 dprintk(2, "qla1280_initialize_adapter: failed to read "
1797 #if LINUX_VERSION_CODE >= 0x020500
1799 * It's necessary to grab the spin here as qla1280_mailbox_command
1800 * needs to be able to drop the lock unconditionally to wait
1802 * In 2.4 ->detect is called with the io_request_lock held.
1804 spin_lock_irqsave(HOST_LOCK
, flags
);
1807 status
= qla1280_load_firmware(ha
);
1809 printk(KERN_ERR
"scsi(%li): initialize: pci probe failed!\n",
1814 /* Setup adapter based on NVRAM parameters. */
1815 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha
->host_no
);
1816 qla1280_nvram_config(ha
);
1818 if (ha
->flags
.disable_host_adapter
) {
1823 status
= qla1280_init_rings(ha
);
1827 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1828 for (bus
= 0; bus
< ha
->ports
; bus
++) {
1829 if (!ha
->bus_settings
[bus
].disable_scsi_reset
&&
1830 qla1280_bus_reset(ha
, bus
) &&
1831 qla1280_bus_reset(ha
, bus
))
1832 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
1835 ha
->flags
.online
= 1;
1837 #if LINUX_VERSION_CODE >= 0x020500
1838 spin_unlock_irqrestore(HOST_LOCK
, flags
);
1841 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1843 LEAVE("qla1280_initialize_adapter");
1850 * Checks if present version of RISC firmware is older than
1854 * ha = adapter block pointer.
1857 * 0 = firmware does not need to be loaded.
1860 qla1280_isp_firmware(struct scsi_qla_host
*ha
)
1862 struct nvram
*nv
= (struct nvram
*) ha
->response_ring
;
1863 int status
= 0; /* dg 2/27 always loads RISC */
1864 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1866 ENTER("qla1280_isp_firmware");
1868 dprintk(1, "scsi(%li): Determining if RISC is loaded\n", ha
->host_no
);
1870 /* Bad NVRAM data, load RISC code. */
1871 if (!ha
->nvram_valid
) {
1872 ha
->flags
.disable_risc_code_load
= 0;
1874 ha
->flags
.disable_risc_code_load
=
1875 nv
->cntr_flags_1
.disable_loading_risc_code
;
1877 if (ha
->flags
.disable_risc_code_load
) {
1878 dprintk(3, "qla1280_isp_firmware: Telling RISC to verify "
1879 "checksum of loaded BIOS code.\n");
1881 /* Verify checksum of loaded RISC code. */
1882 mb
[0] = MBC_VERIFY_CHECKSUM
;
1883 /* mb[1] = ql12_risc_code_addr01; */
1884 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1887 qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]))) {
1888 /* Start firmware execution. */
1889 dprintk(3, "qla1280_isp_firmware: Startng F/W "
1892 mb
[0] = MBC_EXECUTE_FIRMWARE
;
1893 /* mb[1] = ql12_risc_code_addr01; */
1894 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
1895 qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
1897 printk(KERN_INFO
"qla1280: RISC checksum failed.\n");
1899 dprintk(1, "qla1280: NVRAM configured to load RISC load.\n");
1904 dprintk(2, "qla1280_isp_firmware: **** Load RISC code ****\n");
1906 LEAVE("qla1280_isp_firmware");
1912 * Test chip for proper operation.
1915 * ha = adapter block pointer.
1921 qla1280_chip_diag(struct scsi_qla_host
*ha
)
1923 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
1924 struct device_reg
*reg
= ha
->iobase
;
1928 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", ®
->id_l
);
1930 dprintk(1, "scsi(%ld): Verifying chip\n", ha
->host_no
);
1932 /* Soft reset chip and wait for it to finish. */
1933 WRT_REG_WORD(®
->ictrl
, ISP_RESET
);
1936 * We can't do a traditional PCI write flush here by reading
1937 * back the register. The card will not respond once the reset
1938 * is in action and we end up with a machine check exception
1939 * instead. Nothing to do but wait and hope for the best.
1940 * A portable pci_write_flush(pdev) call would be very useful here.
1943 data
= qla1280_debounce_register(®
->ictrl
);
1945 * Yet another QLogic gem ;-(
1947 for (cnt
= 1000000; cnt
&& data
& ISP_RESET
; cnt
--) {
1949 data
= RD_REG_WORD(®
->ictrl
);
1955 /* Reset register cleared by chip reset. */
1956 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1958 WRT_REG_WORD(®
->cfg_1
, 0);
1960 /* Reset RISC and disable BIOS which
1961 allows RISC to execute out of RAM. */
1962 WRT_REG_WORD(®
->host_cmd
, HC_RESET_RISC
|
1963 HC_RELEASE_RISC
| HC_DISABLE_BIOS
);
1965 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
1966 data
= qla1280_debounce_register(®
->mailbox0
);
1969 * I *LOVE* this code!
1971 for (cnt
= 1000000; cnt
&& data
== MBS_BUSY
; cnt
--) {
1973 data
= RD_REG_WORD(®
->mailbox0
);
1979 /* Check product ID of chip */
1980 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1982 if (RD_REG_WORD(®
->mailbox1
) != PROD_ID_1
||
1983 (RD_REG_WORD(®
->mailbox2
) != PROD_ID_2
&&
1984 RD_REG_WORD(®
->mailbox2
) != PROD_ID_2a
) ||
1985 RD_REG_WORD(®
->mailbox3
) != PROD_ID_3
||
1986 RD_REG_WORD(®
->mailbox4
) != PROD_ID_4
) {
1987 printk(KERN_INFO
"qla1280: Wrong product ID = "
1988 "0x%x,0x%x,0x%x,0x%x\n",
1989 RD_REG_WORD(®
->mailbox1
),
1990 RD_REG_WORD(®
->mailbox2
),
1991 RD_REG_WORD(®
->mailbox3
),
1992 RD_REG_WORD(®
->mailbox4
));
1997 * Enable ints early!!!
1999 qla1280_enable_intrs(ha
);
2001 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
2002 /* Wrap Incoming Mailboxes Test. */
2003 mb
[0] = MBC_MAILBOX_REGISTER_TEST
;
2012 status
= qla1280_mailbox_command(ha
, 0xff, mb
);
2016 if (mb
[1] != 0xAAAA || mb
[2] != 0x5555 || mb
[3] != 0xAA55 ||
2017 mb
[4] != 0x55AA || mb
[5] != 0xA5A5 || mb
[6] != 0x5A5A ||
2019 printk(KERN_INFO
"qla1280: Failed mbox check\n");
2023 dprintk(3, "qla1280_chip_diag: exiting normally\n");
2026 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
2031 qla1280_load_firmware_pio(struct scsi_qla_host
*ha
)
2033 uint16_t risc_address
, *risc_code_address
, risc_code_size
;
2034 uint16_t mb
[MAILBOX_REGISTER_COUNT
], i
;
2037 /* Load RISC code. */
2038 risc_address
= *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2039 risc_code_address
= ql1280_board_tbl
[ha
->devnum
].fwcode
;
2040 risc_code_size
= *ql1280_board_tbl
[ha
->devnum
].fwlen
;
2042 for (i
= 0; i
< risc_code_size
; i
++) {
2043 mb
[0] = MBC_WRITE_RAM_WORD
;
2044 mb
[1] = risc_address
+ i
;
2045 mb
[2] = risc_code_address
[i
];
2047 err
= qla1280_mailbox_command(ha
, BIT_0
| BIT_1
| BIT_2
, mb
);
2049 printk(KERN_ERR
"scsi(%li): Failed to load firmware\n",
2058 #define DUMP_IT_BACK 0 /* for debug of RISC loading */
2060 qla1280_load_firmware_dma(struct scsi_qla_host
*ha
)
2062 uint16_t risc_address
, *risc_code_address
, risc_code_size
;
2063 uint16_t mb
[MAILBOX_REGISTER_COUNT
], cnt
;
2064 int err
= 0, num
, i
;
2069 tbuf
= pci_alloc_consistent(ha
->pdev
, 8000, &p_tbuf
);
2074 /* Load RISC code. */
2075 risc_address
= *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2076 risc_code_address
= ql1280_board_tbl
[ha
->devnum
].fwcode
;
2077 risc_code_size
= *ql1280_board_tbl
[ha
->devnum
].fwlen
;
2079 dprintk(1, "%s: DMA RISC code (%i) words\n",
2080 __FUNCTION__
, risc_code_size
);
2083 while (risc_code_size
> 0) {
2084 int warn
__attribute__((unused
)) = 0;
2088 if (cnt
> risc_code_size
)
2089 cnt
= risc_code_size
;
2091 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
2093 risc_code_address
, cnt
, num
, risc_address
);
2094 for(i
= 0; i
< cnt
; i
++)
2095 ((uint16_t *)ha
->request_ring
)[i
] =
2096 cpu_to_le16(risc_code_address
[i
]);
2098 mb
[0] = MBC_LOAD_RAM
;
2099 mb
[1] = risc_address
;
2101 mb
[3] = ha
->request_dma
& 0xffff;
2102 mb
[2] = (ha
->request_dma
>> 16) & 0xffff;
2103 mb
[7] = pci_dma_hi32(ha
->request_dma
) & 0xffff;
2104 mb
[6] = pci_dma_hi32(ha
->request_dma
) >> 16;
2105 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
2106 __FUNCTION__
, mb
[0],
2107 (void *)(long)ha
->request_dma
,
2108 mb
[6], mb
[7], mb
[2], mb
[3]);
2109 err
= qla1280_mailbox_command(ha
, BIT_4
| BIT_3
| BIT_2
|
2112 printk(KERN_ERR
"scsi(%li): Failed to load partial "
2113 "segment of f\n", ha
->host_no
);
2118 mb
[0] = MBC_DUMP_RAM
;
2119 mb
[1] = risc_address
;
2121 mb
[3] = p_tbuf
& 0xffff;
2122 mb
[2] = (p_tbuf
>> 16) & 0xffff;
2123 mb
[7] = pci_dma_hi32(p_tbuf
) & 0xffff;
2124 mb
[6] = pci_dma_hi32(p_tbuf
) >> 16;
2126 err
= qla1280_mailbox_command(ha
, BIT_4
| BIT_3
| BIT_2
|
2130 "Failed to dump partial segment of f/w\n");
2133 sp
= (uint8_t *)ha
->request_ring
;
2134 for (i
= 0; i
< (cnt
<< 1); i
++) {
2135 if (tbuf
[i
] != sp
[i
] && warn
++ < 10) {
2136 printk(KERN_ERR
"%s: FW compare error @ "
2137 "byte(0x%x) loop#=%x\n",
2138 __FUNCTION__
, i
, num
);
2139 printk(KERN_ERR
"%s: FWbyte=%x "
2141 __FUNCTION__
, sp
[i
], tbuf
[i
]);
2146 risc_address
+= cnt
;
2147 risc_code_size
= risc_code_size
- cnt
;
2148 risc_code_address
= risc_code_address
+ cnt
;
2154 pci_free_consistent(ha
->pdev
, 8000, tbuf
, p_tbuf
);
2160 qla1280_start_firmware(struct scsi_qla_host
*ha
)
2162 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2165 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
2168 /* Verify checksum of loaded RISC code. */
2169 mb
[0] = MBC_VERIFY_CHECKSUM
;
2170 /* mb[1] = ql12_risc_code_addr01; */
2171 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2172 err
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, mb
);
2174 printk(KERN_ERR
"scsi(%li): Failed checksum\n", ha
->host_no
);
2178 /* Start firmware execution. */
2179 dprintk(1, "%s: start firmware running.\n", __FUNCTION__
);
2180 mb
[0] = MBC_EXECUTE_FIRMWARE
;
2181 mb
[1] = *ql1280_board_tbl
[ha
->devnum
].fwstart
;
2182 err
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2184 printk(KERN_ERR
"scsi(%li): Failed to start firmware\n",
2192 qla1280_load_firmware(struct scsi_qla_host
*ha
)
2196 /* If firmware needs to be loaded */
2197 if (!qla1280_isp_firmware(ha
)) {
2198 printk(KERN_ERR
"scsi(%li): isp_firmware() failed!\n",
2203 err
= qla1280_chip_diag(ha
);
2207 err
= qla1280_load_firmware_pio(ha
);
2209 err
= qla1280_load_firmware_dma(ha
);
2212 err
= qla1280_start_firmware(ha
);
2221 * ha = adapter block pointer.
2222 * ha->request_ring = request ring virtual address
2223 * ha->response_ring = response ring virtual address
2224 * ha->request_dma = request ring physical address
2225 * ha->response_dma = response ring physical address
2231 qla1280_init_rings(struct scsi_qla_host
*ha
)
2233 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2236 ENTER("qla1280_init_rings");
2238 /* Clear outstanding commands array. */
2239 memset(ha
->outstanding_cmds
, 0,
2240 sizeof(struct srb
*) * MAX_OUTSTANDING_COMMANDS
);
2242 /* Initialize request queue. */
2243 ha
->request_ring_ptr
= ha
->request_ring
;
2244 ha
->req_ring_index
= 0;
2245 ha
->req_q_cnt
= REQUEST_ENTRY_CNT
;
2246 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
2247 mb
[0] = MBC_INIT_REQUEST_QUEUE_A64
;
2248 mb
[1] = REQUEST_ENTRY_CNT
;
2249 mb
[3] = ha
->request_dma
& 0xffff;
2250 mb
[2] = (ha
->request_dma
>> 16) & 0xffff;
2252 mb
[7] = pci_dma_hi32(ha
->request_dma
) & 0xffff;
2253 mb
[6] = pci_dma_hi32(ha
->request_dma
) >> 16;
2254 if (!(status
= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_4
|
2255 BIT_3
| BIT_2
| BIT_1
| BIT_0
,
2257 /* Initialize response queue. */
2258 ha
->response_ring_ptr
= ha
->response_ring
;
2259 ha
->rsp_ring_index
= 0;
2260 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
2261 mb
[0] = MBC_INIT_RESPONSE_QUEUE_A64
;
2262 mb
[1] = RESPONSE_ENTRY_CNT
;
2263 mb
[3] = ha
->response_dma
& 0xffff;
2264 mb
[2] = (ha
->response_dma
>> 16) & 0xffff;
2266 mb
[7] = pci_dma_hi32(ha
->response_dma
) & 0xffff;
2267 mb
[6] = pci_dma_hi32(ha
->response_dma
) >> 16;
2268 status
= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_5
|
2269 BIT_3
| BIT_2
| BIT_1
| BIT_0
,
2274 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
2276 LEAVE("qla1280_init_rings");
2281 qla1280_print_settings(struct nvram
*nv
)
2283 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
2284 nv
->bus
[0].config_1
.initiator_id
);
2285 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
2286 nv
->bus
[1].config_1
.initiator_id
);
2288 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
2289 nv
->bus
[0].bus_reset_delay
);
2290 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
2291 nv
->bus
[1].bus_reset_delay
);
2293 dprintk(1, "qla1280 : retry count[0]=%d\n", nv
->bus
[0].retry_count
);
2294 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv
->bus
[0].retry_delay
);
2295 dprintk(1, "qla1280 : retry count[1]=%d\n", nv
->bus
[1].retry_count
);
2296 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv
->bus
[1].retry_delay
);
2298 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
2299 nv
->bus
[0].config_2
.async_data_setup_time
);
2300 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
2301 nv
->bus
[1].config_2
.async_data_setup_time
);
2303 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
2304 nv
->bus
[0].config_2
.req_ack_active_negation
);
2305 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
2306 nv
->bus
[1].config_2
.req_ack_active_negation
);
2308 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
2309 nv
->bus
[0].config_2
.data_line_active_negation
);
2310 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
2311 nv
->bus
[1].config_2
.data_line_active_negation
);
2313 dprintk(1, "qla1280 : disable loading risc code=%d\n",
2314 nv
->cntr_flags_1
.disable_loading_risc_code
);
2316 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
2317 nv
->cntr_flags_1
.enable_64bit_addressing
);
2319 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
2320 nv
->bus
[0].selection_timeout
);
2321 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
2322 nv
->bus
[1].selection_timeout
);
2324 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
2325 nv
->bus
[0].max_queue_depth
);
2326 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
2327 nv
->bus
[1].max_queue_depth
);
2331 qla1280_set_target_defaults(struct scsi_qla_host
*ha
, int bus
, int target
)
2333 struct nvram
*nv
= &ha
->nvram
;
2335 nv
->bus
[bus
].target
[target
].parameter
.f
.renegotiate_on_error
= 1;
2336 nv
->bus
[bus
].target
[target
].parameter
.f
.auto_request_sense
= 1;
2337 nv
->bus
[bus
].target
[target
].parameter
.f
.tag_queuing
= 1;
2338 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 1;
2339 #if 1 /* Some SCSI Processors do not seem to like this */
2340 nv
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 1;
2342 if (!IS_ISP1040(ha
))
2343 nv
->bus
[bus
].target
[target
].parameter
.f
.parity_checking
= 1;
2345 nv
->bus
[bus
].target
[target
].parameter
.f
.disconnect_allowed
= 1;
2346 nv
->bus
[bus
].target
[target
].execution_throttle
=
2347 nv
->bus
[bus
].max_queue_depth
- 1;
2349 if (IS_ISP1x160(ha
)) {
2350 nv
->bus
[bus
].target
[target
].flags
.flags1x160
.device_enable
= 1;
2351 nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
= 0x0e;
2352 nv
->bus
[bus
].target
[target
].sync_period
= 9;
2353 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 1;
2354 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_options
= 2;
2355 nv
->bus
[bus
].target
[target
].ppr_1x160
.flags
.ppr_bus_width
= 1;
2357 nv
->bus
[bus
].target
[target
].flags
.flags1x80
.device_enable
= 1;
2358 nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
= 12;
2359 nv
->bus
[bus
].target
[target
].sync_period
= 10;
2364 qla1280_set_defaults(struct scsi_qla_host
*ha
)
2366 struct nvram
*nv
= &ha
->nvram
;
2369 dprintk(1, "Using defaults for NVRAM: \n");
2370 memset(nv
, 0, sizeof(struct nvram
));
2372 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2373 nv
->firmware_feature
.f
.enable_fast_posting
= 1;
2374 nv
->firmware_feature
.f
.disable_synchronous_backoff
= 1;
2375 nv
->termination
.f
.scsi_bus_0_control
= 3;
2376 nv
->termination
.f
.scsi_bus_1_control
= 3;
2377 nv
->termination
.f
.auto_term_support
= 1;
2380 * Set default FIFO magic - What appropriate values would be here
2381 * is unknown. This is what I have found testing with 12160s.
2383 * Now, I would love the magic decoder ring for this one, the
2384 * header file provided by QLogic seems to be bogus or incomplete
2387 nv
->isp_config
.c
= ISP_CFG1_BENAB
|ISP_CFG1_F128
;
2388 if (IS_ISP1x160(ha
))
2389 nv
->isp_parameter
= 0x01; /* fast memory enable */
2391 for (bus
= 0; bus
< MAX_BUSES
; bus
++) {
2392 nv
->bus
[bus
].config_1
.initiator_id
= 7;
2393 nv
->bus
[bus
].config_2
.req_ack_active_negation
= 1;
2394 nv
->bus
[bus
].config_2
.data_line_active_negation
= 1;
2395 nv
->bus
[bus
].selection_timeout
= 250;
2396 nv
->bus
[bus
].max_queue_depth
= 256;
2398 if (IS_ISP1040(ha
)) {
2399 nv
->bus
[bus
].bus_reset_delay
= 3;
2400 nv
->bus
[bus
].config_2
.async_data_setup_time
= 6;
2401 nv
->bus
[bus
].retry_delay
= 1;
2403 nv
->bus
[bus
].bus_reset_delay
= 5;
2404 nv
->bus
[bus
].config_2
.async_data_setup_time
= 8;
2407 for (target
= 0; target
< MAX_TARGETS
; target
++)
2408 qla1280_set_target_defaults(ha
, bus
, target
);
2413 qla1280_config_target(struct scsi_qla_host
*ha
, int bus
, int target
)
2415 struct nvram
*nv
= &ha
->nvram
;
2416 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2419 /* Set Target Parameters. */
2420 mb
[0] = MBC_SET_TARGET_PARAMETERS
;
2421 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
2425 * Do not enable wide, sync, and ppr for the initial
2426 * INQUIRY run. We enable this later if we determine
2427 * the target actually supports it.
2429 nv
->bus
[bus
].target
[target
].parameter
.f
.
2430 auto_request_sense
= 1;
2431 nv
->bus
[bus
].target
[target
].parameter
.f
.
2432 stop_queue_on_check
= 0;
2434 if (IS_ISP1x160(ha
))
2435 nv
->bus
[bus
].target
[target
].ppr_1x160
.
2436 flags
.enable_ppr
= 0;
2439 * No sync, wide, etc. while probing
2441 mb
[2] = (nv
->bus
[bus
].target
[target
].parameter
.c
<< 8) &
2442 ~(TP_SYNC
/*| TP_WIDE | TP_PPR*/);
2444 if (IS_ISP1x160(ha
))
2445 mb
[3] = nv
->bus
[bus
].target
[target
].flags
.flags1x160
.sync_offset
<< 8;
2447 mb
[3] = nv
->bus
[bus
].target
[target
].flags
.flags1x80
.sync_offset
<< 8;
2448 mb
[3] |= nv
->bus
[bus
].target
[target
].sync_period
;
2450 status
= qla1280_mailbox_command(ha
, BIT_3
| BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2452 /* Save Tag queuing enable flag. */
2453 mb
[0] = BIT_0
<< target
;
2454 if (nv
->bus
[bus
].target
[target
].parameter
.f
.tag_queuing
)
2455 ha
->bus_settings
[bus
].qtag_enables
|= mb
[0];
2457 /* Save Device enable flag. */
2458 if (IS_ISP1x160(ha
)) {
2459 if (nv
->bus
[bus
].target
[target
].flags
.flags1x160
.device_enable
)
2460 ha
->bus_settings
[bus
].device_enables
|= mb
[0];
2461 ha
->bus_settings
[bus
].lun_disables
|= 0;
2463 if (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.device_enable
)
2464 ha
->bus_settings
[bus
].device_enables
|= mb
[0];
2465 /* Save LUN disable flag. */
2466 if (nv
->bus
[bus
].target
[target
].flags
.flags1x80
.lun_disable
)
2467 ha
->bus_settings
[bus
].lun_disables
|= mb
[0];
2470 /* Set Device Queue Parameters. */
2471 for (lun
= 0; lun
< MAX_LUNS
; lun
++) {
2472 mb
[0] = MBC_SET_DEVICE_QUEUE
;
2473 mb
[1] = (uint16_t)(bus
? target
| BIT_7
: target
);
2474 mb
[1] = mb
[1] << 8 | lun
;
2475 mb
[2] = nv
->bus
[bus
].max_queue_depth
;
2476 mb
[3] = nv
->bus
[bus
].target
[target
].execution_throttle
;
2477 status
|= qla1280_mailbox_command(ha
, 0x0f, &mb
[0]);
2484 qla1280_config_bus(struct scsi_qla_host
*ha
, int bus
)
2486 struct nvram
*nv
= &ha
->nvram
;
2487 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2490 /* SCSI Reset Disable. */
2491 ha
->bus_settings
[bus
].disable_scsi_reset
=
2492 nv
->bus
[bus
].config_1
.scsi_reset_disable
;
2495 ha
->bus_settings
[bus
].id
= nv
->bus
[bus
].config_1
.initiator_id
;
2496 mb
[0] = MBC_SET_INITIATOR_ID
;
2497 mb
[1] = bus
? ha
->bus_settings
[bus
].id
| BIT_7
:
2498 ha
->bus_settings
[bus
].id
;
2499 status
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2502 ha
->bus_settings
[bus
].bus_reset_delay
=
2503 nv
->bus
[bus
].bus_reset_delay
;
2505 /* Command queue depth per device. */
2506 ha
->bus_settings
[bus
].hiwat
= nv
->bus
[bus
].max_queue_depth
- 1;
2508 /* Set target parameters. */
2509 for (target
= 0; target
< MAX_TARGETS
; target
++)
2510 status
|= qla1280_config_target(ha
, bus
, target
);
2516 qla1280_nvram_config(struct scsi_qla_host
*ha
)
2518 struct device_reg
*reg
= ha
->iobase
;
2519 struct nvram
*nv
= &ha
->nvram
;
2520 int bus
, target
, status
= 0;
2521 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2524 ENTER("qla1280_nvram_config");
2526 if (ha
->nvram_valid
) {
2527 /* Always force AUTO sense for LINUX SCSI */
2528 for (bus
= 0; bus
< MAX_BUSES
; bus
++)
2529 for (target
= 0; target
< MAX_TARGETS
; target
++) {
2530 nv
->bus
[bus
].target
[target
].parameter
.f
.
2531 auto_request_sense
= 1;
2534 qla1280_set_defaults(ha
);
2537 qla1280_print_settings(nv
);
2539 /* Disable RISC load of firmware. */
2540 ha
->flags
.disable_risc_code_load
=
2541 nv
->cntr_flags_1
.disable_loading_risc_code
;
2543 if (IS_ISP1040(ha
)) {
2544 uint16_t hwrev
, cfg1
, cdma_conf
, ddma_conf
;
2546 hwrev
= RD_REG_WORD(®
->cfg_0
) & ISP_CFG0_HWMSK
;
2548 cfg1
= RD_REG_WORD(®
->cfg_1
);
2549 cdma_conf
= RD_REG_WORD(®
->cdma_cfg
);
2550 ddma_conf
= RD_REG_WORD(®
->ddma_cfg
);
2552 /* Busted fifo, says mjacob. */
2553 if (hwrev
== ISP_CFG0_1040A
)
2554 WRT_REG_WORD(®
->cfg_1
, cfg1
| ISP_CFG1_F64
);
2556 WRT_REG_WORD(®
->cfg_1
, cfg1
| ISP_CFG1_F64
| ISP_CFG1_BENAB
);
2558 WRT_REG_WORD(®
->cdma_cfg
, cdma_conf
| CDMA_CONF_BENAB
);
2559 WRT_REG_WORD(®
->ddma_cfg
, cdma_conf
| DDMA_CONF_BENAB
);
2561 /* Set ISP hardware DMA burst */
2562 mb
[0] = nv
->isp_config
.c
;
2563 /* Enable DMA arbitration on dual channel controllers */
2566 WRT_REG_WORD(®
->cfg_1
, mb
[0]);
2568 /* Set SCSI termination. */
2569 WRT_REG_WORD(®
->gpio_enable
, (BIT_3
+ BIT_2
+ BIT_1
+ BIT_0
));
2570 mb
[0] = nv
->termination
.c
& (BIT_3
+ BIT_2
+ BIT_1
+ BIT_0
);
2571 WRT_REG_WORD(®
->gpio_data
, mb
[0]);
2574 /* ISP parameter word. */
2575 mb
[0] = MBC_SET_SYSTEM_PARAMETER
;
2576 mb
[1] = nv
->isp_parameter
;
2577 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2579 if (IS_ISP1x40(ha
)) {
2580 /* clock rate - for qla1240 and older, only */
2581 mb
[0] = MBC_SET_CLOCK_RATE
;
2583 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, mb
);
2586 /* Firmware feature word. */
2587 mb
[0] = MBC_SET_FIRMWARE_FEATURES
;
2588 mask
= BIT_5
| BIT_1
| BIT_0
;
2589 mb
[1] = le16_to_cpu(nv
->firmware_feature
.w
) & (mask
);
2590 #if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2591 if (ia64_platform_is("sn2")) {
2592 printk(KERN_INFO
"scsi(%li): Enabling SN2 PCI DMA "
2593 "workaround\n", ha
->host_no
);
2597 status
|= qla1280_mailbox_command(ha
, mask
, &mb
[0]);
2599 /* Retry count and delay. */
2600 mb
[0] = MBC_SET_RETRY_COUNT
;
2601 mb
[1] = nv
->bus
[0].retry_count
;
2602 mb
[2] = nv
->bus
[0].retry_delay
;
2603 mb
[6] = nv
->bus
[1].retry_count
;
2604 mb
[7] = nv
->bus
[1].retry_delay
;
2605 status
|= qla1280_mailbox_command(ha
, BIT_7
| BIT_6
| BIT_2
|
2606 BIT_1
| BIT_0
, &mb
[0]);
2608 /* ASYNC data setup time. */
2609 mb
[0] = MBC_SET_ASYNC_DATA_SETUP
;
2610 mb
[1] = nv
->bus
[0].config_2
.async_data_setup_time
;
2611 mb
[2] = nv
->bus
[1].config_2
.async_data_setup_time
;
2612 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2614 /* Active negation states. */
2615 mb
[0] = MBC_SET_ACTIVE_NEGATION
;
2617 if (nv
->bus
[0].config_2
.req_ack_active_negation
)
2619 if (nv
->bus
[0].config_2
.data_line_active_negation
)
2622 if (nv
->bus
[1].config_2
.req_ack_active_negation
)
2624 if (nv
->bus
[1].config_2
.data_line_active_negation
)
2626 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2628 mb
[0] = MBC_SET_DATA_OVERRUN_RECOVERY
;
2629 mb
[1] = 2; /* Reset SCSI bus and return all outstanding IO */
2630 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2633 mb
[0] = MBC_SET_PCI_CONTROL
;
2634 mb
[1] = 2; /* Data DMA Channel Burst Enable */
2635 mb
[2] = 2; /* Command DMA Channel Burst Enable */
2636 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2638 mb
[0] = MBC_SET_TAG_AGE_LIMIT
;
2640 status
|= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
2642 /* Selection timeout. */
2643 mb
[0] = MBC_SET_SELECTION_TIMEOUT
;
2644 mb
[1] = nv
->bus
[0].selection_timeout
;
2645 mb
[2] = nv
->bus
[1].selection_timeout
;
2646 status
|= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2648 for (bus
= 0; bus
< ha
->ports
; bus
++)
2649 status
|= qla1280_config_bus(ha
, bus
);
2652 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2654 LEAVE("qla1280_nvram_config");
2659 * Get NVRAM data word
2660 * Calculates word position in NVRAM and calls request routine to
2661 * get the word from NVRAM.
2664 * ha = adapter block pointer.
2665 * address = NVRAM word address.
2671 qla1280_get_nvram_word(struct scsi_qla_host
*ha
, uint32_t address
)
2676 nv_cmd
= address
<< 16;
2677 nv_cmd
|= NV_READ_OP
;
2679 data
= le16_to_cpu(qla1280_nvram_request(ha
, nv_cmd
));
2681 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2689 * Sends read command to NVRAM and gets data from NVRAM.
2692 * ha = adapter block pointer.
2693 * nv_cmd = Bit 26 = start bit
2694 * Bit 25, 24 = opcode
2695 * Bit 23-16 = address
2696 * Bit 15-0 = write data
2702 qla1280_nvram_request(struct scsi_qla_host
*ha
, uint32_t nv_cmd
)
2704 struct device_reg
*reg
= ha
->iobase
;
2709 /* Send command to NVRAM. */
2712 for (cnt
= 0; cnt
< 11; cnt
++) {
2713 if (nv_cmd
& BIT_31
)
2714 qla1280_nv_write(ha
, NV_DATA_OUT
);
2716 qla1280_nv_write(ha
, 0);
2720 /* Read data from NVRAM. */
2722 for (cnt
= 0; cnt
< 16; cnt
++) {
2723 WRT_REG_WORD(®
->nvram
, (NV_SELECT
| NV_CLOCK
));
2724 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2727 reg_data
= RD_REG_WORD(®
->nvram
);
2728 if (reg_data
& NV_DATA_IN
)
2730 WRT_REG_WORD(®
->nvram
, NV_SELECT
);
2731 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2735 /* Deselect chip. */
2737 WRT_REG_WORD(®
->nvram
, NV_DESELECT
);
2738 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2745 qla1280_nv_write(struct scsi_qla_host
*ha
, uint16_t data
)
2747 struct device_reg
*reg
= ha
->iobase
;
2749 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
);
2750 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2752 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
| NV_CLOCK
);
2753 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2755 WRT_REG_WORD(®
->nvram
, data
| NV_SELECT
);
2756 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
2762 * Issue mailbox command and waits for completion.
2765 * ha = adapter block pointer.
2766 * mr = mailbox registers to load.
2767 * mb = data pointer for mailbox registers.
2770 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2776 qla1280_mailbox_command(struct scsi_qla_host
*ha
, uint8_t mr
, uint16_t *mb
)
2778 struct device_reg
*reg
= ha
->iobase
;
2784 uint16_t *optr
, *iptr
;
2786 DECLARE_COMPLETION(wait
);
2787 struct timer_list timer
;
2789 ENTER("qla1280_mailbox_command");
2791 if (ha
->mailbox_wait
) {
2792 printk(KERN_ERR
"Warning mailbox wait already in use!\n");
2794 ha
->mailbox_wait
= &wait
;
2797 * We really should start out by verifying that the mailbox is
2798 * available before starting sending the command data
2800 /* Load mailbox registers. */
2801 optr
= (uint16_t *) ®
->mailbox0
;
2803 for (cnt
= 0; cnt
< MAILBOX_REGISTER_COUNT
; cnt
++) {
2805 WRT_REG_WORD(optr
, (*iptr
));
2813 /* Issue set host interrupt command. */
2815 /* set up a timer just in case we're really jammed */
2817 timer
.expires
= jiffies
+ 20*HZ
;
2818 timer
.data
= (unsigned long)ha
;
2819 timer
.function
= qla1280_mailbox_timeout
;
2822 spin_unlock_irq(HOST_LOCK
);
2823 WRT_REG_WORD(®
->host_cmd
, HC_SET_HOST_INT
);
2824 data
= qla1280_debounce_register(®
->istatus
);
2826 wait_for_completion(&wait
);
2827 del_timer_sync(&timer
);
2829 spin_lock_irq(HOST_LOCK
);
2831 ha
->mailbox_wait
= NULL
;
2833 /* Check for mailbox command timeout. */
2834 if (ha
->mailbox_out
[0] != MBS_CMD_CMP
) {
2835 printk(KERN_WARNING
"qla1280_mailbox_command: Command failed, "
2836 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2838 mb
[0], ha
->mailbox_out
[0], RD_REG_WORD(®
->istatus
));
2839 printk(KERN_WARNING
"m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2840 RD_REG_WORD(®
->mailbox0
), RD_REG_WORD(®
->mailbox1
),
2841 RD_REG_WORD(®
->mailbox2
), RD_REG_WORD(®
->mailbox3
));
2842 printk(KERN_WARNING
"m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2843 RD_REG_WORD(®
->mailbox4
), RD_REG_WORD(®
->mailbox5
),
2844 RD_REG_WORD(®
->mailbox6
), RD_REG_WORD(®
->mailbox7
));
2848 /* Load return mailbox registers. */
2850 iptr
= (uint16_t *) &ha
->mailbox_out
[0];
2851 mr
= MAILBOX_REGISTER_COUNT
;
2852 memcpy(optr
, iptr
, MAILBOX_REGISTER_COUNT
* sizeof(uint16_t));
2855 /* Go check for any response interrupts pending. */
2856 qla1280_isr(ha
, &done_q
);
2859 if (ha
->flags
.reset_marker
)
2860 qla1280_rst_aen(ha
);
2863 if (!list_empty(&done_q
))
2864 qla1280_done(ha
, &done_q
);
2868 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2869 "0x%x ****\n", mb
[0]);
2871 LEAVE("qla1280_mailbox_command");
2877 * Polls ISP for interrupts.
2880 * ha = adapter block pointer.
2883 qla1280_poll(struct scsi_qla_host
*ha
)
2885 struct device_reg
*reg
= ha
->iobase
;
2889 /* ENTER("qla1280_poll"); */
2891 /* Check for pending interrupts. */
2892 data
= RD_REG_WORD(®
->istatus
);
2893 if (data
& RISC_INT
)
2894 qla1280_isr(ha
, &done_q
);
2896 if (!ha
->mailbox_wait
) {
2897 if (ha
->flags
.reset_marker
)
2898 qla1280_rst_aen(ha
);
2901 if (!list_empty(&done_q
))
2904 /* LEAVE("qla1280_poll"); */
2909 * Issue SCSI bus reset.
2912 * ha = adapter block pointer.
2913 * bus = SCSI bus number.
2919 qla1280_bus_reset(struct scsi_qla_host
*ha
, int bus
)
2921 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2922 uint16_t reset_delay
;
2925 dprintk(3, "qla1280_bus_reset: entered\n");
2927 if (qla1280_verbose
)
2928 printk(KERN_INFO
"scsi(%li:%i): Resetting SCSI BUS\n",
2931 reset_delay
= ha
->bus_settings
[bus
].bus_reset_delay
;
2932 mb
[0] = MBC_BUS_RESET
;
2933 mb
[1] = reset_delay
;
2934 mb
[2] = (uint16_t) bus
;
2935 status
= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2938 if (ha
->bus_settings
[bus
].failed_reset_count
> 2)
2939 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
2940 ha
->bus_settings
[bus
].failed_reset_count
++;
2942 spin_unlock_irq(HOST_LOCK
);
2943 schedule_timeout(reset_delay
* HZ
);
2944 spin_lock_irq(HOST_LOCK
);
2946 ha
->bus_settings
[bus
].scsi_bus_dead
= 0;
2947 ha
->bus_settings
[bus
].failed_reset_count
= 0;
2948 ha
->bus_settings
[bus
].reset_marker
= 0;
2949 /* Issue marker command. */
2950 qla1280_marker(ha
, bus
, 0, 0, MK_SYNC_ALL
);
2954 * We should probably call qla1280_set_target_parameters()
2955 * here as well for all devices on the bus.
2959 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2961 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2967 * qla1280_device_reset
2968 * Issue bus device reset message to the target.
2971 * ha = adapter block pointer.
2972 * bus = SCSI BUS number.
2979 qla1280_device_reset(struct scsi_qla_host
*ha
, int bus
, int target
)
2981 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
2984 ENTER("qla1280_device_reset");
2986 mb
[0] = MBC_ABORT_TARGET
;
2987 mb
[1] = (bus
? (target
| BIT_7
) : target
) << 8;
2989 status
= qla1280_mailbox_command(ha
, BIT_2
| BIT_1
| BIT_0
, &mb
[0]);
2991 /* Issue marker command. */
2992 qla1280_marker(ha
, bus
, target
, 0, MK_SYNC_ID
);
2995 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2997 LEAVE("qla1280_device_reset");
3002 * qla1280_abort_device
3003 * Issue an abort message to the device
3006 * ha = adapter block pointer.
3015 qla1280_abort_device(struct scsi_qla_host
*ha
, int bus
, int target
, int lun
)
3017 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
3020 ENTER("qla1280_abort_device");
3022 mb
[0] = MBC_ABORT_DEVICE
;
3023 mb
[1] = (bus
? target
| BIT_7
: target
) << 8 | lun
;
3024 status
= qla1280_mailbox_command(ha
, BIT_1
| BIT_0
, &mb
[0]);
3026 /* Issue marker command. */
3027 qla1280_marker(ha
, bus
, target
, lun
, MK_SYNC_ID_LUN
);
3030 dprintk(2, "qla1280_abort_device: **** FAILED ****\n");
3032 LEAVE("qla1280_abort_device");
3037 * qla1280_abort_command
3038 * Abort command aborts a specified IOCB.
3041 * ha = adapter block pointer.
3042 * sp = SB structure pointer.
3048 qla1280_abort_command(struct scsi_qla_host
*ha
, struct srb
* sp
, int handle
)
3050 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
3051 unsigned int bus
, target
, lun
;
3054 ENTER("qla1280_abort_command");
3056 bus
= SCSI_BUS_32(sp
->cmd
);
3057 target
= SCSI_TCN_32(sp
->cmd
);
3058 lun
= SCSI_LUN_32(sp
->cmd
);
3060 sp
->flags
|= SRB_ABORT_PENDING
;
3062 mb
[0] = MBC_ABORT_COMMAND
;
3063 mb
[1] = (bus
? target
| BIT_7
: target
) << 8 | lun
;
3064 mb
[2] = handle
>> 16;
3065 mb
[3] = handle
& 0xffff;
3066 status
= qla1280_mailbox_command(ha
, 0x0f, &mb
[0]);
3069 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
3070 sp
->flags
&= ~SRB_ABORT_PENDING
;
3074 LEAVE("qla1280_abort_command");
3079 * qla1280_reset_adapter
3083 * ha = adapter block pointer.
3086 qla1280_reset_adapter(struct scsi_qla_host
*ha
)
3088 struct device_reg
*reg
= ha
->iobase
;
3090 ENTER("qla1280_reset_adapter");
3092 /* Disable ISP chip */
3093 ha
->flags
.online
= 0;
3094 WRT_REG_WORD(®
->ictrl
, ISP_RESET
);
3095 WRT_REG_WORD(®
->host_cmd
,
3096 HC_RESET_RISC
| HC_RELEASE_RISC
| HC_DISABLE_BIOS
);
3097 RD_REG_WORD(®
->id_l
); /* Flush PCI write */
3099 LEAVE("qla1280_reset_adapter");
3103 * Issue marker command.
3104 * Function issues marker IOCB.
3107 * ha = adapter block pointer.
3108 * bus = SCSI BUS number
3111 * type = marker modifier
3114 qla1280_marker(struct scsi_qla_host
*ha
, int bus
, int id
, int lun
, u8 type
)
3116 struct mrk_entry
*pkt
;
3118 ENTER("qla1280_marker");
3120 /* Get request packet. */
3121 if ((pkt
= (struct mrk_entry
*) qla1280_req_pkt(ha
))) {
3122 pkt
->entry_type
= MARKER_TYPE
;
3123 pkt
->lun
= (uint8_t) lun
;
3124 pkt
->target
= (uint8_t) (bus
? (id
| BIT_7
) : id
);
3125 pkt
->modifier
= type
;
3126 pkt
->entry_status
= 0;
3128 /* Issue command to ISP */
3129 qla1280_isp_cmd(ha
);
3132 LEAVE("qla1280_marker");
3137 * qla1280_64bit_start_scsi
3138 * The start SCSI is responsible for building request packets on
3139 * request ring and modifying ISP input pointer.
3142 * ha = adapter block pointer.
3143 * sp = SB structure pointer.
3146 * 0 = success, was able to issue command.
3148 #ifdef QLA_64BIT_PTR
3150 qla1280_64bit_start_scsi(struct scsi_qla_host
*ha
, struct srb
* sp
)
3152 struct device_reg
*reg
= ha
->iobase
;
3153 struct scsi_cmnd
*cmd
= sp
->cmd
;
3154 cmd_a64_entry_t
*pkt
;
3155 struct scatterlist
*sg
= NULL
;
3157 dma_addr_t dma_handle
;
3164 ENTER("qla1280_64bit_start_scsi:");
3166 /* Calculate number of entries and segments required. */
3169 sg
= (struct scatterlist
*) cmd
->request_buffer
;
3170 seg_cnt
= pci_map_sg(ha
->pdev
, sg
, cmd
->use_sg
,
3171 cmd
->sc_data_direction
);
3174 req_cnt
+= (seg_cnt
- 2) / 5;
3175 if ((seg_cnt
- 2) % 5)
3178 } else if (cmd
->request_bufflen
) { /* If data transfer. */
3184 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3185 /* Calculate number of free request entries. */
3186 cnt
= RD_REG_WORD(®
->mailbox4
);
3187 if (ha
->req_ring_index
< cnt
)
3188 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3191 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3194 /* If room for request in request ring. */
3195 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3197 dprintk(2, "qla1280_64bit_start_scsi: in-ptr=0x%x req_q_cnt="
3198 "0x%xreq_cnt=0x%x", ha
->req_ring_index
, ha
->req_q_cnt
,
3203 /* Check for room in outstanding command list. */
3204 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
&&
3205 ha
->outstanding_cmds
[cnt
] != 0; cnt
++);
3207 if (cnt
>= MAX_OUTSTANDING_COMMANDS
) {
3209 dprintk(2, "qla1280_64bit_start_scsi: NO ROOM IN "
3210 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha
->req_q_cnt
);
3214 ha
->outstanding_cmds
[cnt
] = sp
;
3215 ha
->req_q_cnt
-= req_cnt
;
3216 CMD_HANDLE(sp
->cmd
) = (unsigned char *)(unsigned long)(cnt
+ 1);
3218 dprintk(2, "64bit_start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd
, sp
,
3219 cmd
->cmnd
[0], (long)CMD_HANDLE(sp
->cmd
));
3220 dprintk(2, " bus %i, target %i, lun %i\n",
3221 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3222 qla1280_dump_buffer(2, cmd
->cmnd
, MAX_COMMAND_SIZE
);
3225 * Build command packet.
3227 pkt
= (cmd_a64_entry_t
*) ha
->request_ring_ptr
;
3229 pkt
->entry_type
= COMMAND_A64_TYPE
;
3230 pkt
->entry_count
= (uint8_t) req_cnt
;
3231 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3232 pkt
->entry_status
= 0;
3233 pkt
->handle
= cpu_to_le32(cnt
);
3235 /* Zero out remaining portion of packet. */
3236 memset(((char *)pkt
+ 8), 0, (REQUEST_ENTRY_SIZE
- 8));
3238 /* Set ISP command timeout. */
3239 pkt
->timeout
= cpu_to_le16(30);
3241 /* Set device target ID and LUN */
3242 pkt
->lun
= SCSI_LUN_32(cmd
);
3243 pkt
->target
= SCSI_BUS_32(cmd
) ?
3244 (SCSI_TCN_32(cmd
) | BIT_7
) : SCSI_TCN_32(cmd
);
3246 /* Enable simple tag queuing if device supports it. */
3247 if (DEV_SIMPLE_TAGS(cmd
->device
))
3248 pkt
->control_flags
|= cpu_to_le16(BIT_3
);
3250 /* Load SCSI command packet. */
3251 pkt
->cdb_len
= cpu_to_le16(CMD_CDBLEN(cmd
));
3252 memcpy(pkt
->scsi_cdb
, &(CMD_CDBP(cmd
)), CMD_CDBLEN(cmd
));
3253 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3255 /* Set transfer direction. */
3256 dir
= qla1280_data_direction(cmd
);
3257 pkt
->control_flags
|= cpu_to_le16(dir
);
3259 /* Set total data segment count. */
3260 pkt
->dseg_count
= cpu_to_le16(seg_cnt
);
3263 * Load data segments.
3265 if (seg_cnt
) { /* If data transfer. */
3266 /* Setup packet address segment pointer. */
3267 dword_ptr
= (u32
*)&pkt
->dseg_0_address
;
3269 if (cmd
->use_sg
) { /* If scatter gather */
3270 /* Load command entry data segments. */
3271 for (cnt
= 0; cnt
< 2 && seg_cnt
; cnt
++, seg_cnt
--) {
3272 dma_handle
= sg_dma_address(sg
);
3273 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3274 if (ha
->flags
.use_pci_vchannel
)
3275 sn_pci_set_vchan(ha
->pdev
, &dma_handle
,
3279 cpu_to_le32(pci_dma_lo32(dma_handle
));
3281 cpu_to_le32(pci_dma_hi32(dma_handle
));
3282 *dword_ptr
++ = cpu_to_le32(sg_dma_len(sg
));
3284 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
3285 cpu_to_le32(pci_dma_hi32(dma_handle
)),
3286 cpu_to_le32(pci_dma_lo32(dma_handle
)),
3287 cpu_to_le32(sg_dma_len(sg
)));
3289 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
3290 "command packet data - b %i, t %i, l %i \n",
3291 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
),
3293 qla1280_dump_buffer(5, (char *)pkt
,
3294 REQUEST_ENTRY_SIZE
);
3297 * Build continuation packets.
3299 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
3300 "remains\n", seg_cnt
);
3302 while (seg_cnt
> 0) {
3303 /* Adjust ring index. */
3304 ha
->req_ring_index
++;
3305 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3306 ha
->req_ring_index
= 0;
3307 ha
->request_ring_ptr
=
3310 ha
->request_ring_ptr
++;
3312 pkt
= (cmd_a64_entry_t
*)ha
->request_ring_ptr
;
3314 /* Zero out packet. */
3315 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3317 /* Load packet defaults. */
3318 ((struct cont_a64_entry
*) pkt
)->entry_type
=
3320 ((struct cont_a64_entry
*) pkt
)->entry_count
= 1;
3321 ((struct cont_a64_entry
*) pkt
)->sys_define
=
3322 (uint8_t)ha
->req_ring_index
;
3323 /* Setup packet address segment pointer. */
3325 (u32
*)&((struct cont_a64_entry
*) pkt
)->dseg_0_address
;
3327 /* Load continuation entry data segments. */
3328 for (cnt
= 0; cnt
< 5 && seg_cnt
;
3330 dma_handle
= sg_dma_address(sg
);
3331 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3332 if (ha
->flags
.use_pci_vchannel
)
3333 sn_pci_set_vchan(ha
->pdev
, &dma_handle
,
3337 cpu_to_le32(pci_dma_lo32(dma_handle
));
3339 cpu_to_le32(pci_dma_hi32(dma_handle
));
3341 cpu_to_le32(sg_dma_len(sg
));
3342 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
3343 cpu_to_le32(pci_dma_hi32(dma_handle
)),
3344 cpu_to_le32(pci_dma_lo32(dma_handle
)),
3345 cpu_to_le32(sg_dma_len(sg
)));
3348 dprintk(5, "qla1280_64bit_start_scsi: "
3349 "continuation packet data - b %i, t "
3350 "%i, l %i \n", SCSI_BUS_32(cmd
),
3351 SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3352 qla1280_dump_buffer(5, (char *)pkt
,
3353 REQUEST_ENTRY_SIZE
);
3355 } else { /* No scatter gather data transfer */
3356 struct page
*page
= virt_to_page(cmd
->request_buffer
);
3357 unsigned long off
= (unsigned long)cmd
->request_buffer
& ~PAGE_MASK
;
3359 dma_handle
= pci_map_page(ha
->pdev
, page
, off
,
3360 cmd
->request_bufflen
,
3361 cmd
->sc_data_direction
);
3363 /* save dma_handle for pci_unmap_page */
3364 sp
->saved_dma_handle
= dma_handle
;
3365 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3366 if (ha
->flags
.use_pci_vchannel
)
3367 sn_pci_set_vchan(ha
->pdev
, &dma_handle
,
3370 *dword_ptr
++ = cpu_to_le32(pci_dma_lo32(dma_handle
));
3371 *dword_ptr
++ = cpu_to_le32(pci_dma_hi32(dma_handle
));
3372 *dword_ptr
= cpu_to_le32(cmd
->request_bufflen
);
3374 dprintk(5, "qla1280_64bit_start_scsi: No scatter/"
3375 "gather command packet data - b %i, t %i, "
3376 "l %i \n", SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
),
3378 qla1280_dump_buffer(5, (char *)pkt
,
3379 REQUEST_ENTRY_SIZE
);
3381 } else { /* No data transfer */
3382 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
3383 "packet data - b %i, t %i, l %i \n",
3384 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3385 qla1280_dump_buffer(5, (char *)pkt
, REQUEST_ENTRY_SIZE
);
3387 /* Adjust ring index. */
3388 ha
->req_ring_index
++;
3389 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3390 ha
->req_ring_index
= 0;
3391 ha
->request_ring_ptr
= ha
->request_ring
;
3393 ha
->request_ring_ptr
++;
3395 /* Set chip new ring index. */
3397 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3398 sp
->flags
|= SRB_SENT
;
3400 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3401 (void) RD_REG_WORD(®
->mailbox4
); /* PCI posted write flush */
3405 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3407 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3411 #else /* !QLA_64BIT_PTR */
3414 * qla1280_32bit_start_scsi
3415 * The start SCSI is responsible for building request packets on
3416 * request ring and modifying ISP input pointer.
3418 * The Qlogic firmware interface allows every queue slot to have a SCSI
3419 * command and up to 4 scatter/gather (SG) entries. If we need more
3420 * than 4 SG entries, then continuation entries are used that can
3421 * hold another 7 entries each. The start routine determines if there
3422 * is eought empty slots then build the combination of requests to
3423 * fulfill the OS request.
3426 * ha = adapter block pointer.
3427 * sp = SCSI Request Block structure pointer.
3430 * 0 = success, was able to issue command.
3433 qla1280_32bit_start_scsi(struct scsi_qla_host
*ha
, struct srb
* sp
)
3435 struct device_reg
*reg
= ha
->iobase
;
3436 struct scsi_cmnd
*cmd
= sp
->cmd
;
3437 struct cmd_entry
*pkt
;
3438 struct scatterlist
*sg
= NULL
;
3439 uint32_t *dword_ptr
;
3444 dma_addr_t dma_handle
;
3447 ENTER("qla1280_32bit_start_scsi");
3449 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd
, sp
,
3452 /* Calculate number of entries and segments required. */
3456 * We must build an SG list in adapter format, as the kernel's
3457 * SG list cannot be used directly because of data field size
3458 * (__alpha__) differences and the kernel SG list uses virtual
3459 * addresses where we need physical addresses.
3461 sg
= (struct scatterlist
*) cmd
->request_buffer
;
3462 seg_cnt
= pci_map_sg(ha
->pdev
, sg
, cmd
->use_sg
,
3463 cmd
->sc_data_direction
);
3466 * if greater than four sg entries then we need to allocate
3467 * continuation entries
3470 req_cnt
+= (seg_cnt
- 4) / 7;
3471 if ((seg_cnt
- 4) % 7)
3474 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3475 cmd
, seg_cnt
, req_cnt
);
3476 } else if (cmd
->request_bufflen
) { /* If data transfer. */
3477 dprintk(3, "No S/G transfer t=%x cmd=%p len=%x CDB=%x\n",
3478 SCSI_TCN_32(cmd
), cmd
, cmd
->request_bufflen
,
3482 /* dprintk(1, "No data transfer \n"); */
3486 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3487 /* Calculate number of free request entries. */
3488 cnt
= RD_REG_WORD(®
->mailbox4
);
3489 if (ha
->req_ring_index
< cnt
)
3490 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3493 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3496 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3497 ha
->req_q_cnt
, seg_cnt
);
3498 /* If room for request in request ring. */
3499 if ((req_cnt
+ 2) >= ha
->req_q_cnt
) {
3501 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3502 "req_q_cnt=0x%x, req_cnt=0x%x", ha
->req_ring_index
,
3503 ha
->req_q_cnt
, req_cnt
);
3507 /* Check for empty slot in outstanding command list. */
3508 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
&&
3509 (ha
->outstanding_cmds
[cnt
] != 0); cnt
++) ;
3511 if (cnt
>= MAX_OUTSTANDING_COMMANDS
) {
3513 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3514 "ARRAY, req_q_cnt=0x%x\n", ha
->req_q_cnt
);
3518 CMD_HANDLE(sp
->cmd
) = (unsigned char *) (unsigned long)(cnt
+ 1);
3519 ha
->outstanding_cmds
[cnt
] = sp
;
3520 ha
->req_q_cnt
-= req_cnt
;
3523 * Build command packet.
3525 pkt
= (struct cmd_entry
*) ha
->request_ring_ptr
;
3527 pkt
->entry_type
= COMMAND_TYPE
;
3528 pkt
->entry_count
= (uint8_t) req_cnt
;
3529 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3530 pkt
->entry_status
= 0;
3531 pkt
->handle
= cpu_to_le32(cnt
);
3533 /* Zero out remaining portion of packet. */
3534 memset(((char *)pkt
+ 8), 0, (REQUEST_ENTRY_SIZE
- 8));
3536 /* Set ISP command timeout. */
3537 pkt
->timeout
= cpu_to_le16(30);
3539 /* Set device target ID and LUN */
3540 pkt
->lun
= SCSI_LUN_32(cmd
);
3541 pkt
->target
= SCSI_BUS_32(cmd
) ?
3542 (SCSI_TCN_32(cmd
) | BIT_7
) : SCSI_TCN_32(cmd
);
3544 /* Enable simple tag queuing if device supports it. */
3545 if (DEV_SIMPLE_TAGS(cmd
->device
))
3546 pkt
->control_flags
|= cpu_to_le16(BIT_3
);
3548 /* Load SCSI command packet. */
3549 pkt
->cdb_len
= cpu_to_le16(CMD_CDBLEN(cmd
));
3550 memcpy(pkt
->scsi_cdb
, &(CMD_CDBP(cmd
)), CMD_CDBLEN(cmd
));
3552 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3553 /* Set transfer direction. */
3554 dir
= qla1280_data_direction(cmd
);
3555 pkt
->control_flags
|= cpu_to_le16(dir
);
3557 /* Set total data segment count. */
3558 pkt
->dseg_count
= cpu_to_le16(seg_cnt
);
3561 * Load data segments.
3564 /* Setup packet address segment pointer. */
3565 dword_ptr
= &pkt
->dseg_0_address
;
3567 if (cmd
->use_sg
) { /* If scatter gather */
3568 dprintk(3, "Building S/G data segments..\n");
3569 qla1280_dump_buffer(1, (char *)sg
, 4 * 16);
3571 /* Load command entry data segments. */
3572 for (cnt
= 0; cnt
< 4 && seg_cnt
; cnt
++, seg_cnt
--) {
3574 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
)));
3576 cpu_to_le32(sg_dma_len(sg
));
3577 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3578 (pci_dma_lo32(sg_dma_address(sg
))),
3583 * Build continuation packets.
3585 dprintk(3, "S/G Building Continuation"
3586 "...seg_cnt=0x%x remains\n", seg_cnt
);
3587 while (seg_cnt
> 0) {
3588 /* Adjust ring index. */
3589 ha
->req_ring_index
++;
3590 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3591 ha
->req_ring_index
= 0;
3592 ha
->request_ring_ptr
=
3595 ha
->request_ring_ptr
++;
3597 pkt
= (struct cmd_entry
*)ha
->request_ring_ptr
;
3599 /* Zero out packet. */
3600 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3602 /* Load packet defaults. */
3603 ((struct cont_entry
*) pkt
)->
3604 entry_type
= CONTINUE_TYPE
;
3605 ((struct cont_entry
*) pkt
)->entry_count
= 1;
3607 ((struct cont_entry
*) pkt
)->sys_define
=
3608 (uint8_t) ha
->req_ring_index
;
3610 /* Setup packet address segment pointer. */
3612 &((struct cont_entry
*) pkt
)->dseg_0_address
;
3614 /* Load continuation entry data segments. */
3615 for (cnt
= 0; cnt
< 7 && seg_cnt
;
3618 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
)));
3620 cpu_to_le32(sg_dma_len(sg
));
3622 "S/G Segment Cont. phys_addr=0x%x, "
3624 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg
))),
3625 cpu_to_le32(sg_dma_len(sg
)));
3628 dprintk(5, "qla1280_32bit_start_scsi: "
3629 "continuation packet data - "
3630 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd
),
3631 SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
));
3632 qla1280_dump_buffer(5, (char *)pkt
,
3633 REQUEST_ENTRY_SIZE
);
3635 } else { /* No S/G data transfer */
3636 struct page
*page
= virt_to_page(cmd
->request_buffer
);
3637 unsigned long off
= (unsigned long)cmd
->request_buffer
& ~PAGE_MASK
;
3638 dma_handle
= pci_map_page(ha
->pdev
, page
, off
,
3639 cmd
->request_bufflen
,
3640 cmd
->sc_data_direction
);
3641 sp
->saved_dma_handle
= dma_handle
;
3643 *dword_ptr
++ = cpu_to_le32(pci_dma_lo32(dma_handle
));
3644 *dword_ptr
= cpu_to_le32(cmd
->request_bufflen
);
3646 } else { /* No data transfer at all */
3647 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3648 "packet data - \n");
3649 qla1280_dump_buffer(5, (char *)pkt
, REQUEST_ENTRY_SIZE
);
3651 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3652 qla1280_dump_buffer(5, (char *)ha
->request_ring_ptr
,
3653 REQUEST_ENTRY_SIZE
);
3655 /* Adjust ring index. */
3656 ha
->req_ring_index
++;
3657 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3658 ha
->req_ring_index
= 0;
3659 ha
->request_ring_ptr
= ha
->request_ring
;
3661 ha
->request_ring_ptr
++;
3663 /* Set chip new ring index. */
3664 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3665 "for pending command\n");
3666 sp
->flags
|= SRB_SENT
;
3668 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3669 (void) RD_REG_WORD(®
->mailbox4
); /* PCI posted write flush */
3673 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3675 LEAVE("qla1280_32bit_start_scsi");
3683 * Function is responsible for locking ring and
3684 * getting a zeroed out request packet.
3687 * ha = adapter block pointer.
3690 * 0 = failed to get slot.
3693 qla1280_req_pkt(struct scsi_qla_host
*ha
)
3695 struct device_reg
*reg
= ha
->iobase
;
3696 request_t
*pkt
= NULL
;
3700 ENTER("qla1280_req_pkt");
3703 * This can be called from interrupt context, damn it!!!
3705 /* Wait for 30 seconds for slot. */
3706 for (timer
= 15000000; timer
; timer
--) {
3707 if (ha
->req_q_cnt
> 0) {
3708 /* Calculate number of free request entries. */
3709 cnt
= RD_REG_WORD(®
->mailbox4
);
3710 if (ha
->req_ring_index
< cnt
)
3711 ha
->req_q_cnt
= cnt
- ha
->req_ring_index
;
3714 REQUEST_ENTRY_CNT
- (ha
->req_ring_index
- cnt
);
3717 /* Found empty request ring slot? */
3718 if (ha
->req_q_cnt
> 0) {
3720 pkt
= ha
->request_ring_ptr
;
3722 /* Zero out packet. */
3723 memset(pkt
, 0, REQUEST_ENTRY_SIZE
);
3726 * How can this be right when we have a ring
3729 /* Set system defined field. */
3730 pkt
->sys_define
= (uint8_t) ha
->req_ring_index
;
3732 /* Set entry count. */
3733 pkt
->entry_count
= 1;
3740 /* Check for pending interrupts. */
3745 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3747 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3754 * Function is responsible for modifying ISP input pointer.
3755 * Releases ring lock.
3758 * ha = adapter block pointer.
3761 qla1280_isp_cmd(struct scsi_qla_host
*ha
)
3763 struct device_reg
*reg
= ha
->iobase
;
3765 ENTER("qla1280_isp_cmd");
3767 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3768 qla1280_dump_buffer(5, (char *)ha
->request_ring_ptr
,
3769 REQUEST_ENTRY_SIZE
);
3771 /* Adjust ring index. */
3772 ha
->req_ring_index
++;
3773 if (ha
->req_ring_index
== REQUEST_ENTRY_CNT
) {
3774 ha
->req_ring_index
= 0;
3775 ha
->request_ring_ptr
= ha
->request_ring
;
3777 ha
->request_ring_ptr
++;
3779 /* Set chip new ring index. */
3780 WRT_REG_WORD(®
->mailbox4
, ha
->req_ring_index
);
3781 (void) RD_REG_WORD(®
->mailbox4
); /* PCI posted write flush */
3783 LEAVE("qla1280_isp_cmd");
3786 /****************************************************************************/
3787 /* Interrupt Service Routine. */
3788 /****************************************************************************/
3790 /****************************************************************************
3792 * Calls I/O done on command completion.
3795 * ha = adapter block pointer.
3796 * done_q = done queue.
3797 ****************************************************************************/
3799 qla1280_isr(struct scsi_qla_host
*ha
, struct list_head
*done_q
)
3801 struct device_reg
*reg
= ha
->iobase
;
3802 struct response
*pkt
;
3803 struct srb
*sp
= NULL
;
3804 uint16_t mailbox
[MAILBOX_REGISTER_COUNT
];
3809 ENTER("qla1280_isr");
3811 istatus
= RD_REG_WORD(®
->istatus
);
3812 if (!(istatus
& (RISC_INT
| PCI_INT
)))
3815 /* Save mailbox register 5 */
3816 mailbox
[5] = RD_REG_WORD(®
->mailbox5
);
3818 /* Check for mailbox interrupt. */
3820 mailbox
[0] = RD_REG_WORD_dmasync(®
->semaphore
);
3822 if (mailbox
[0] & BIT_0
) {
3823 /* Get mailbox data. */
3824 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3827 *wptr
++ = RD_REG_WORD(®
->mailbox0
);
3828 *wptr
++ = RD_REG_WORD(®
->mailbox1
);
3829 *wptr
= RD_REG_WORD(®
->mailbox2
);
3830 if (mailbox
[0] != MBA_SCSI_COMPLETION
) {
3832 *wptr
++ = RD_REG_WORD(®
->mailbox3
);
3833 *wptr
++ = RD_REG_WORD(®
->mailbox4
);
3835 *wptr
++ = RD_REG_WORD(®
->mailbox6
);
3836 *wptr
= RD_REG_WORD(®
->mailbox7
);
3839 /* Release mailbox registers. */
3841 WRT_REG_WORD(®
->semaphore
, 0);
3842 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
3844 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3847 /* Handle asynchronous event */
3848 switch (mailbox
[0]) {
3849 case MBA_SCSI_COMPLETION
: /* Response completion */
3850 dprintk(5, "qla1280_isr: mailbox SCSI response "
3853 if (ha
->flags
.online
) {
3854 /* Get outstanding command index. */
3855 index
= mailbox
[2] << 16 | mailbox
[1];
3857 /* Validate handle. */
3858 if (index
< MAX_OUTSTANDING_COMMANDS
)
3859 sp
= ha
->outstanding_cmds
[index
];
3864 /* Free outstanding command slot. */
3865 ha
->outstanding_cmds
[index
] = NULL
;
3867 /* Save ISP completion status */
3868 CMD_RESULT(sp
->cmd
) = 0;
3870 /* Place block on done queue */
3871 list_add_tail(&sp
->list
, done_q
);
3874 * If we get here we have a real problem!
3877 "qla1280: ISP invalid handle");
3882 case MBA_BUS_RESET
: /* SCSI Bus Reset */
3883 ha
->flags
.reset_marker
= 1;
3884 index
= mailbox
[6] & BIT_0
;
3885 ha
->bus_settings
[index
].reset_marker
= 1;
3887 printk(KERN_DEBUG
"qla1280_isr(): index %i "
3888 "asynchronous BUS_RESET\n", index
);
3891 case MBA_SYSTEM_ERR
: /* System Error */
3893 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3894 "%xh, mbx3=%xh\n", mailbox
[1], mailbox
[2],
3898 case MBA_REQ_TRANSFER_ERR
: /* Request Transfer Error */
3900 "qla1280: ISP Request Transfer Error\n");
3903 case MBA_RSP_TRANSFER_ERR
: /* Response Transfer Error */
3905 "qla1280: ISP Response Transfer Error\n");
3908 case MBA_WAKEUP_THRES
: /* Request Queue Wake-up */
3909 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3912 case MBA_TIMEOUT_RESET
: /* Execution Timeout Reset */
3914 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3917 case MBA_DEVICE_RESET
: /* Bus Device Reset */
3918 printk(KERN_INFO
"qla1280_isr(): asynchronous "
3919 "BUS_DEVICE_RESET\n");
3921 ha
->flags
.reset_marker
= 1;
3922 index
= mailbox
[6] & BIT_0
;
3923 ha
->bus_settings
[index
].reset_marker
= 1;
3926 case MBA_BUS_MODE_CHANGE
:
3928 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3932 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3933 if (mailbox
[0] < MBA_ASYNC_EVENT
) {
3935 memcpy((uint16_t *) ha
->mailbox_out
, wptr
,
3936 MAILBOX_REGISTER_COUNT
*
3939 if(ha
->mailbox_wait
!= NULL
)
3940 complete(ha
->mailbox_wait
);
3945 WRT_REG_WORD(®
->host_cmd
, HC_CLR_RISC_INT
);
3949 * We will receive interrupts during mailbox testing prior to
3950 * the card being marked online, hence the double check.
3952 if (!(ha
->flags
.online
&& !ha
->mailbox_wait
)) {
3953 dprintk(2, "qla1280_isr: Response pointer Error\n");
3957 if (mailbox
[5] >= RESPONSE_ENTRY_CNT
)
3960 while (ha
->rsp_ring_index
!= mailbox
[5]) {
3961 pkt
= ha
->response_ring_ptr
;
3963 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3964 " = 0x%x\n", ha
->rsp_ring_index
, mailbox
[5]);
3965 dprintk(5,"qla1280_isr: response packet data\n");
3966 qla1280_dump_buffer(5, (char *)pkt
, RESPONSE_ENTRY_SIZE
);
3968 if (pkt
->entry_type
== STATUS_TYPE
) {
3969 if ((le16_to_cpu(pkt
->scsi_status
) & 0xff)
3970 || pkt
->comp_status
|| pkt
->entry_status
) {
3971 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3972 "0x%x mailbox[5] = 0x%x, comp_status "
3973 "= 0x%x, scsi_status = 0x%x\n",
3974 ha
->rsp_ring_index
, mailbox
[5],
3975 le16_to_cpu(pkt
->comp_status
),
3976 le16_to_cpu(pkt
->scsi_status
));
3979 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3980 "0x%x, mailbox[5] = 0x%x\n",
3981 ha
->rsp_ring_index
, mailbox
[5]);
3982 dprintk(2, "qla1280_isr: response packet data\n");
3983 qla1280_dump_buffer(2, (char *)pkt
,
3984 RESPONSE_ENTRY_SIZE
);
3987 if (pkt
->entry_type
== STATUS_TYPE
|| pkt
->entry_status
) {
3988 dprintk(2, "status: Cmd %p, handle %i\n",
3989 ha
->outstanding_cmds
[pkt
->handle
]->cmd
,
3991 if (pkt
->entry_type
== STATUS_TYPE
)
3992 qla1280_status_entry(ha
, pkt
, done_q
);
3994 qla1280_error_entry(ha
, pkt
, done_q
);
3995 /* Adjust ring index. */
3996 ha
->rsp_ring_index
++;
3997 if (ha
->rsp_ring_index
== RESPONSE_ENTRY_CNT
) {
3998 ha
->rsp_ring_index
= 0;
3999 ha
->response_ring_ptr
= ha
->response_ring
;
4001 ha
->response_ring_ptr
++;
4002 WRT_REG_WORD(®
->mailbox5
, ha
->rsp_ring_index
);
4007 LEAVE("qla1280_isr");
4012 * Processes asynchronous reset.
4015 * ha = adapter block pointer.
4018 qla1280_rst_aen(struct scsi_qla_host
*ha
)
4022 ENTER("qla1280_rst_aen");
4024 if (ha
->flags
.online
&& !ha
->flags
.reset_active
&&
4025 !ha
->flags
.abort_isp_active
) {
4026 ha
->flags
.reset_active
= 1;
4027 while (ha
->flags
.reset_marker
) {
4028 /* Issue marker command. */
4029 ha
->flags
.reset_marker
= 0;
4030 for (bus
= 0; bus
< ha
->ports
&&
4031 !ha
->flags
.reset_marker
; bus
++) {
4032 if (ha
->bus_settings
[bus
].reset_marker
) {
4033 ha
->bus_settings
[bus
].reset_marker
= 0;
4034 qla1280_marker(ha
, bus
, 0, 0,
4041 LEAVE("qla1280_rst_aen");
4045 #if LINUX_VERSION_CODE < 0x020500
4050 qla1280_get_target_options(struct scsi_cmnd
*cmd
, struct scsi_qla_host
*ha
)
4052 unsigned char *result
;
4054 int bus
, target
, lun
;
4056 bus
= SCSI_BUS_32(cmd
);
4057 target
= SCSI_TCN_32(cmd
);
4058 lun
= SCSI_LUN_32(cmd
);
4061 * Make sure to not touch anything if someone is using the
4064 if (cmd
->use_sg
|| (CMD_RESULT(cmd
) >> 16) != DID_OK
|| lun
)
4067 result
= cmd
->request_buffer
;
4070 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 0;
4071 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 0;
4072 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 0;
4074 if (result
[7] & 0x60)
4075 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
= 1;
4076 if (result
[7] & 0x10)
4077 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
= 1;
4078 if ((result
[2] >= 3) && (result
[4] + 5 > 56) &&
4080 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
= 1;
4082 dprintk(2, "get_target_options(): wide %i, sync %i, ppr %i\n",
4083 n
->bus
[bus
].target
[target
].parameter
.f
.enable_wide
,
4084 n
->bus
[bus
].target
[target
].parameter
.f
.enable_sync
,
4085 n
->bus
[bus
].target
[target
].ppr_1x160
.flags
.enable_ppr
);
4090 * qla1280_status_entry
4091 * Processes received ISP status entry.
4094 * ha = adapter block pointer.
4095 * pkt = entry pointer.
4096 * done_q = done queue.
4099 qla1280_status_entry(struct scsi_qla_host
*ha
, struct response
*pkt
,
4100 struct list_head
*done_q
)
4102 unsigned int bus
, target
, lun
;
4105 struct scsi_cmnd
*cmd
;
4106 uint32_t handle
= le32_to_cpu(pkt
->handle
);
4107 uint16_t scsi_status
= le16_to_cpu(pkt
->scsi_status
);
4108 uint16_t comp_status
= le16_to_cpu(pkt
->comp_status
);
4110 ENTER("qla1280_status_entry");
4112 /* Validate handle. */
4113 if (handle
< MAX_OUTSTANDING_COMMANDS
)
4114 sp
= ha
->outstanding_cmds
[handle
];
4119 printk(KERN_WARNING
"qla1280: Status Entry invalid handle\n");
4123 /* Free outstanding command slot. */
4124 ha
->outstanding_cmds
[handle
] = NULL
;
4128 /* Generate LU queue on cntrl, target, LUN */
4129 bus
= SCSI_BUS_32(cmd
);
4130 target
= SCSI_TCN_32(cmd
);
4131 lun
= SCSI_LUN_32(cmd
);
4133 if (comp_status
|| scsi_status
) {
4134 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
4135 "0x%x, handle = 0x%x\n", comp_status
,
4136 scsi_status
, handle
);
4140 if (scsi_status
& SS_BUSY_CONDITION
&&
4141 scsi_status
!= SS_RESERVE_CONFLICT
) {
4143 DID_BUS_BUSY
<< 16 | (scsi_status
& 0xff);
4146 /* Save ISP completion status */
4147 CMD_RESULT(cmd
) = qla1280_return_status(pkt
, cmd
);
4149 if (scsi_status
& SS_CHECK_CONDITION
) {
4150 if (comp_status
!= CS_ARS_FAILED
) {
4151 uint16_t req_sense_length
=
4152 le16_to_cpu(pkt
->req_sense_length
);
4153 if (req_sense_length
< CMD_SNSLEN(cmd
))
4154 sense_sz
= req_sense_length
;
4157 * scsi_cmnd->sense_buffer is
4158 * 64 bytes, why only copy 63?
4159 * This looks wrong! /Jes
4161 sense_sz
= CMD_SNSLEN(cmd
) - 1;
4163 memcpy(cmd
->sense_buffer
,
4164 &pkt
->req_sense_data
, sense_sz
);
4167 memset(cmd
->sense_buffer
+ sense_sz
, 0,
4168 sizeof(cmd
->sense_buffer
) - sense_sz
);
4170 dprintk(2, "qla1280_status_entry: Check "
4171 "condition Sense data, b %i, t %i, "
4172 "l %i\n", bus
, target
, lun
);
4174 qla1280_dump_buffer(2,
4175 (char *)cmd
->sense_buffer
,
4180 /* Place command on done queue. */
4181 list_add_tail(&sp
->list
, done_q
);
4183 LEAVE("qla1280_status_entry");
4187 * qla1280_error_entry
4188 * Processes error entry.
4191 * ha = adapter block pointer.
4192 * pkt = entry pointer.
4193 * done_q = done queue.
4196 qla1280_error_entry(struct scsi_qla_host
*ha
, struct response
*pkt
,
4197 struct list_head
*done_q
)
4200 uint32_t handle
= le32_to_cpu(pkt
->handle
);
4202 ENTER("qla1280_error_entry");
4204 if (pkt
->entry_status
& BIT_3
)
4205 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
4206 else if (pkt
->entry_status
& BIT_2
)
4207 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
4208 else if (pkt
->entry_status
& BIT_1
)
4209 dprintk(2, "qla1280_error_entry: FULL flag error\n");
4211 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
4213 /* Validate handle. */
4214 if (handle
< MAX_OUTSTANDING_COMMANDS
)
4215 sp
= ha
->outstanding_cmds
[handle
];
4220 /* Free outstanding command slot. */
4221 ha
->outstanding_cmds
[handle
] = NULL
;
4223 /* Bad payload or header */
4224 if (pkt
->entry_status
& (BIT_3
+ BIT_2
)) {
4225 /* Bad payload or header, set error status. */
4226 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
4227 CMD_RESULT(sp
->cmd
) = DID_ERROR
<< 16;
4228 } else if (pkt
->entry_status
& BIT_1
) { /* FULL flag */
4229 CMD_RESULT(sp
->cmd
) = DID_BUS_BUSY
<< 16;
4231 /* Set error status. */
4232 CMD_RESULT(sp
->cmd
) = DID_ERROR
<< 16;
4235 /* Place command on done queue. */
4236 list_add_tail(&sp
->list
, done_q
);
4238 #ifdef QLA_64BIT_PTR
4239 else if (pkt
->entry_type
== COMMAND_A64_TYPE
) {
4240 printk(KERN_WARNING
"!qla1280: Error Entry invalid handle");
4244 LEAVE("qla1280_error_entry");
4249 * Resets ISP and aborts all outstanding commands.
4252 * ha = adapter block pointer.
4258 qla1280_abort_isp(struct scsi_qla_host
*ha
)
4260 struct device_reg
*reg
= ha
->iobase
;
4266 ENTER("qla1280_abort_isp");
4268 if (ha
->flags
.abort_isp_active
|| !ha
->flags
.online
)
4271 ha
->flags
.abort_isp_active
= 1;
4273 /* Disable ISP interrupts. */
4274 qla1280_disable_intrs(ha
);
4275 WRT_REG_WORD(®
->host_cmd
, HC_PAUSE_RISC
);
4276 RD_REG_WORD(®
->id_l
);
4278 printk(KERN_INFO
"scsi(%li): dequeuing outstanding commands\n",
4280 /* Dequeue all commands in outstanding command list. */
4281 for (cnt
= 0; cnt
< MAX_OUTSTANDING_COMMANDS
; cnt
++) {
4282 struct scsi_cmnd
*cmd
;
4283 sp
= ha
->outstanding_cmds
[cnt
];
4287 CMD_RESULT(cmd
) = DID_RESET
<< 16;
4290 ha
->outstanding_cmds
[cnt
] = NULL
;
4292 (*cmd
->scsi_done
)(cmd
);
4298 status
= qla1280_load_firmware(ha
);
4302 /* Setup adapter based on NVRAM parameters. */
4303 qla1280_nvram_config (ha
);
4305 status
= qla1280_init_rings(ha
);
4309 /* Issue SCSI reset. */
4310 for (bus
= 0; bus
< ha
->ports
; bus
++)
4311 qla1280_bus_reset(ha
, bus
);
4313 ha
->flags
.abort_isp_active
= 0;
4317 "qla1280: ISP error recovery failed, board disabled");
4318 qla1280_reset_adapter(ha
);
4319 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
4322 LEAVE("qla1280_abort_isp");
4328 * qla1280_debounce_register
4329 * Debounce register.
4332 * port = register address.
4338 qla1280_debounce_register(volatile u16
* addr
)
4343 ret
= RD_REG_WORD(addr
);
4344 ret2
= RD_REG_WORD(addr
);
4351 ret
= RD_REG_WORD(addr
);
4352 ret2
= RD_REG_WORD(addr
);
4353 } while (ret
!= ret2
);
4359 /************************************************************************
4360 * qla1280_check_for_dead_scsi_bus *
4362 * This routine checks for a dead SCSI bus *
4363 ************************************************************************/
4364 #define SET_SXP_BANK 0x0100
4365 #define SCSI_PHASE_INVALID 0x87FF
4367 qla1280_check_for_dead_scsi_bus(struct scsi_qla_host
*ha
, unsigned int bus
)
4369 uint16_t config_reg
, scsi_control
;
4370 struct device_reg
*reg
= ha
->iobase
;
4372 if (ha
->bus_settings
[bus
].scsi_bus_dead
) {
4373 WRT_REG_WORD(®
->host_cmd
, HC_PAUSE_RISC
);
4374 config_reg
= RD_REG_WORD(®
->cfg_1
);
4375 WRT_REG_WORD(®
->cfg_1
, SET_SXP_BANK
);
4376 scsi_control
= RD_REG_WORD(®
->scsiControlPins
);
4377 WRT_REG_WORD(®
->cfg_1
, config_reg
);
4378 WRT_REG_WORD(®
->host_cmd
, HC_RELEASE_RISC
);
4380 if (scsi_control
== SCSI_PHASE_INVALID
) {
4381 ha
->bus_settings
[bus
].scsi_bus_dead
= 1;
4383 CMD_RESULT(cp
) = DID_NO_CONNECT
<< 16;
4384 CMD_HANDLE(cp
) = INVALID_HANDLE
;
4385 /* ha->actthreads--; */
4387 (*(cp
)->scsi_done
)(cp
);
4389 return 1; /* bus is dead */
4391 ha
->bus_settings
[bus
].scsi_bus_dead
= 0;
4392 ha
->bus_settings
[bus
].failed_reset_count
= 0;
4395 return 0; /* bus is not dead */
4399 qla1280_get_target_parameters(struct scsi_qla_host
*ha
,
4400 struct scsi_device
*device
)
4402 uint16_t mb
[MAILBOX_REGISTER_COUNT
];
4403 int bus
, target
, lun
;
4405 bus
= device
->channel
;
4406 target
= device
->id
;
4410 mb
[0] = MBC_GET_TARGET_PARAMETERS
;
4411 mb
[1] = (uint16_t) (bus
? target
| BIT_7
: target
);
4413 qla1280_mailbox_command(ha
, BIT_6
| BIT_3
| BIT_2
| BIT_1
| BIT_0
,
4416 printk(KERN_INFO
"scsi(%li:%d:%d:%d):", ha
->host_no
, bus
, target
, lun
);
4419 printk(" Sync: period %d, offset %d",
4420 (mb
[3] & 0xff), (mb
[3] >> 8));
4423 if ((mb
[2] & BIT_5
) && ((mb
[6] >> 8) & 0xff) >= 2)
4428 if (DEV_SIMPLE_TAGS(device
))
4429 printk(", Tagged queuing: depth %d", device
->queue_depth
);
4436 __qla1280_dump_buffer(char *b
, int size
)
4441 printk(KERN_DEBUG
" 0 1 2 3 4 5 6 7 8 9 Ah "
4442 "Bh Ch Dh Eh Fh\n");
4443 printk(KERN_DEBUG
"---------------------------------------------"
4444 "------------------\n");
4446 for (cnt
= 0; cnt
< size
;) {
4449 printk("0x%02x", c
);
4460 /**************************************************************************
4461 * ql1280_print_scsi_cmd
4463 **************************************************************************/
4465 __qla1280_print_scsi_cmd(struct scsi_cmnd
*cmd
)
4467 struct scsi_qla_host
*ha
;
4468 struct Scsi_Host
*host
= CMD_HOST(cmd
);
4470 /* struct scatterlist *sg; */
4473 ha
= (struct scsi_qla_host
*)host
->hostdata
;
4475 sp
= (struct srb
*)CMD_SP(cmd
);
4476 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd
, CMD_HANDLE(cmd
));
4477 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4478 SCSI_BUS_32(cmd
), SCSI_TCN_32(cmd
), SCSI_LUN_32(cmd
),
4481 for (i
= 0; i
< cmd
->cmd_len
; i
++) {
4482 printk("0x%02x ", cmd
->cmnd
[i
]);
4484 printk(" seg_cnt =%d\n", cmd
->use_sg
);
4485 printk(" request buffer=0x%p, request buffer len=0x%x\n",
4486 cmd
->request_buffer
, cmd
->request_bufflen
);
4489 sg = (struct scatterlist *) cmd->request_buffer;
4490 printk(" SG buffer: \n");
4491 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4493 printk(" tag=%d, transfersize=0x%x \n",
4494 cmd
->tag
, cmd
->transfersize
);
4495 printk(" Pid=%li, SP=0x%p\n", cmd
->pid
, CMD_SP(cmd
));
4496 printk(" underflow size = 0x%x, direction=0x%x\n",
4497 cmd
->underflow
, cmd
->sc_data_direction
);
4500 /**************************************************************************
4501 * ql1280_dump_device
4503 **************************************************************************/
4505 ql1280_dump_device(struct scsi_qla_host
*ha
)
4508 struct scsi_cmnd
*cp
;
4512 printk(KERN_DEBUG
"Outstanding Commands on controller:\n");
4514 for (i
= 0; i
< MAX_OUTSTANDING_COMMANDS
; i
++) {
4515 if ((sp
= ha
->outstanding_cmds
[i
]) == NULL
)
4517 if ((cp
= sp
->cmd
) == NULL
)
4519 qla1280_print_scsi_cmd(1, cp
);
4534 struct setup_tokens
{
4539 static struct setup_tokens setup_token
[] __initdata
=
4541 { "nvram", TOKEN_NVRAM
},
4542 { "sync", TOKEN_SYNC
},
4543 { "wide", TOKEN_WIDE
},
4544 { "ppr", TOKEN_PPR
},
4545 { "verbose", TOKEN_VERBOSE
},
4546 { "debug", TOKEN_DEBUG
},
4550 /**************************************************************************
4553 * Handle boot parameters. This really needs to be changed so one
4554 * can specify per adapter parameters.
4555 **************************************************************************/
4557 qla1280_setup(char *s
)
4565 while (cp
&& (ptr
= strchr(cp
, ':'))) {
4567 if (!strcmp(ptr
, "yes")) {
4570 } else if (!strcmp(ptr
, "no")) {
4574 val
= simple_strtoul(ptr
, &ptr
, 0);
4576 switch ((toke
= qla1280_get_token(cp
))) {
4579 driver_setup
.no_nvram
= 1;
4583 driver_setup
.no_sync
= 1;
4584 else if (val
!= 0x10000)
4585 driver_setup
.sync_mask
= val
;
4589 driver_setup
.no_wide
= 1;
4590 else if (val
!= 0x10000)
4591 driver_setup
.wide_mask
= val
;
4595 driver_setup
.no_ppr
= 1;
4596 else if (val
!= 0x10000)
4597 driver_setup
.ppr_mask
= val
;
4600 qla1280_verbose
= val
;
4603 printk(KERN_INFO
"qla1280: unknown boot option %s\n",
4607 cp
= strchr(ptr
, ';');
4619 qla1280_get_token(char *str
)
4625 len
= sizeof(setup_token
)/sizeof(struct setup_tokens
);
4627 sep
= strchr(str
, ':');
4630 for (i
= 0; i
< len
; i
++){
4632 if (!strncmp(setup_token
[i
].token
, str
, (sep
- str
))) {
4633 ret
= setup_token
[i
].val
;
4642 #if LINUX_VERSION_CODE >= 0x020600
4643 static struct scsi_host_template qla1280_driver_template
= {
4644 .proc_name
= "qla1280",
4645 .name
= "Qlogic ISP 1280/12160",
4646 .info
= qla1280_info
,
4647 .slave_configure
= qla1280_slave_configure
,
4648 .queuecommand
= qla1280_queuecommand
,
4649 .eh_abort_handler
= qla1280_eh_abort
,
4650 .eh_device_reset_handler
= qla1280_eh_device_reset
,
4651 .eh_bus_reset_handler
= qla1280_eh_bus_reset
,
4652 .eh_host_reset_handler
= qla1280_eh_adapter_reset
,
4653 .bios_param
= qla1280_biosparam
,
4654 .proc_info
= qla1280_proc_info
,
4655 .can_queue
= 0xfffff,
4657 .sg_tablesize
= SG_ALL
,
4659 .use_clustering
= ENABLE_CLUSTERING
,
4662 static Scsi_Host_Template qla1280_driver_template
= {
4663 .proc_name
= "qla1280",
4664 .name
= "Qlogic ISP 1280/12160",
4665 .detect
= qla1280_detect
,
4666 .release
= qla1280_release
,
4667 .info
= qla1280_info
,
4668 .queuecommand
= qla1280_queuecommand
,
4669 .eh_abort_handler
= qla1280_eh_abort
,
4670 .eh_device_reset_handler
= qla1280_eh_device_reset
,
4671 .eh_bus_reset_handler
= qla1280_eh_bus_reset
,
4672 .eh_host_reset_handler
= qla1280_eh_adapter_reset
,
4673 .bios_param
= qla1280_biosparam_old
,
4674 .proc_info
= qla1280_proc_info_old
,
4675 .can_queue
= 0xfffff,
4677 .sg_tablesize
= SG_ALL
,
4679 .use_clustering
= ENABLE_CLUSTERING
,
4680 .use_new_eh_code
= 1,
4684 static int __devinit
4685 qla1280_probe_one(struct pci_dev
*pdev
, const struct pci_device_id
*id
)
4687 int devnum
= id
->driver_data
;
4688 struct qla_boards
*bdp
= &ql1280_board_tbl
[devnum
];
4689 struct Scsi_Host
*host
;
4690 struct scsi_qla_host
*ha
;
4691 int error
= -ENODEV
;
4693 /* Bypass all AMI SUBSYS VENDOR IDs */
4694 if (pdev
->subsystem_vendor
== PCI_VENDOR_ID_AMI
) {
4696 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4700 printk(KERN_INFO
"qla1280: %s found on PCI bus %i, dev %i\n",
4701 bdp
->name
, pdev
->bus
->number
, PCI_SLOT(pdev
->devfn
));
4703 if (pci_enable_device(pdev
)) {
4705 "qla1280: Failed to enabled pci device, aborting.\n");
4709 pci_set_master(pdev
);
4712 host
= scsi_host_alloc(&qla1280_driver_template
, sizeof(*ha
));
4715 "qla1280: Failed to register host, aborting.\n");
4716 goto error_disable_device
;
4719 ha
= (struct scsi_qla_host
*)host
->hostdata
;
4720 memset(ha
, 0, sizeof(struct scsi_qla_host
));
4723 ha
->devnum
= devnum
; /* specifies microcode load address */
4725 #ifdef QLA_64BIT_PTR
4726 if (pci_set_dma_mask(ha
->pdev
, (dma_addr_t
) ~ 0ULL)) {
4727 if (pci_set_dma_mask(ha
->pdev
, 0xffffffff)) {
4728 printk(KERN_WARNING
"scsi(%li): Unable to set a "
4729 " suitable DMA mask - aboring\n", ha
->host_no
);
4731 goto error_free_irq
;
4734 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4737 if (pci_set_dma_mask(ha
->pdev
, 0xffffffff)) {
4738 printk(KERN_WARNING
"scsi(%li): Unable to set a "
4739 " suitable DMA mask - aboring\n", ha
->host_no
);
4741 goto error_free_irq
;
4745 ha
->request_ring
= pci_alloc_consistent(ha
->pdev
,
4746 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4748 if (!ha
->request_ring
) {
4749 printk(KERN_INFO
"qla1280: Failed to get request memory\n");
4750 goto error_put_host
;
4753 ha
->response_ring
= pci_alloc_consistent(ha
->pdev
,
4754 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4756 if (!ha
->response_ring
) {
4757 printk(KERN_INFO
"qla1280: Failed to get response memory\n");
4758 goto error_free_request_ring
;
4761 ha
->ports
= bdp
->numPorts
;
4764 ha
->host_no
= host
->host_no
;
4766 host
->irq
= pdev
->irq
;
4767 host
->max_channel
= bdp
->numPorts
- 1;
4768 host
->max_lun
= MAX_LUNS
- 1;
4769 host
->max_id
= MAX_TARGETS
;
4770 host
->max_sectors
= 1024;
4771 host
->unique_id
= host
->host_no
;
4773 #if LINUX_VERSION_CODE < 0x020545
4774 host
->select_queue_depths
= qla1280_select_queue_depth
;
4779 #if MEMORY_MAPPED_IO
4780 ha
->mmpbase
= ioremap(pci_resource_start(ha
->pdev
, 1),
4781 pci_resource_len(ha
->pdev
, 1));
4783 printk(KERN_INFO
"qla1280: Unable to map I/O memory\n");
4784 goto error_free_response_ring
;
4787 host
->base
= (unsigned long)ha
->mmpbase
;
4788 ha
->iobase
= (struct device_reg
*)ha
->mmpbase
;
4790 host
->io_port
= pci_resource_start(ha
->pdev
, 0);
4791 if (!request_region(host
->io_port
, 0xff, "qla1280")) {
4792 printk(KERN_INFO
"qla1280: Failed to reserve i/o region "
4793 "0x%04lx-0x%04lx - already in use\n",
4794 host
->io_port
, host
->io_port
+ 0xff);
4795 goto error_free_response_ring
;
4798 ha
->iobase
= (struct device_reg
*)host
->io_port
;
4801 INIT_LIST_HEAD(&ha
->done_q
);
4803 /* Disable ISP interrupts. */
4804 qla1280_disable_intrs(ha
);
4806 if (request_irq(pdev
->irq
, qla1280_intr_handler
, SA_SHIRQ
,
4808 printk("qla1280 : Failed to reserve interrupt %d already "
4809 "in use\n", pdev
->irq
);
4810 goto error_release_region
;
4813 /* load the F/W, read paramaters, and init the H/W */
4814 if (qla1280_initialize_adapter(ha
)) {
4815 printk(KERN_INFO
"qla1x160: Failed to initialize adapter\n");
4816 goto error_free_irq
;
4819 /* set our host ID (need to do something about our two IDs) */
4820 host
->this_id
= ha
->bus_settings
[0].id
;
4822 pci_set_drvdata(pdev
, host
);
4824 #if LINUX_VERSION_CODE >= 0x020600
4825 error
= scsi_add_host(host
, &pdev
->dev
);
4827 goto error_disable_adapter
;
4828 scsi_scan_host(host
);
4830 scsi_set_pci_device(host
, pdev
);
4835 #if LINUX_VERSION_CODE >= 0x020600
4836 error_disable_adapter
:
4837 WRT_REG_WORD(&ha
->iobase
->ictrl
, 0);
4840 free_irq(pdev
->irq
, ha
);
4841 error_release_region
:
4842 #if MEMORY_MAPPED_IO
4843 iounmap(ha
->mmpbase
);
4845 release_region(host
->io_port
, 0xff);
4847 error_free_response_ring
:
4848 pci_free_consistent(ha
->pdev
,
4849 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4850 ha
->response_ring
, ha
->response_dma
);
4851 error_free_request_ring
:
4852 pci_free_consistent(ha
->pdev
,
4853 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4854 ha
->request_ring
, ha
->request_dma
);
4856 scsi_host_put(host
);
4857 error_disable_device
:
4858 pci_disable_device(pdev
);
4864 static void __devexit
4865 qla1280_remove_one(struct pci_dev
*pdev
)
4867 struct Scsi_Host
*host
= pci_get_drvdata(pdev
);
4868 struct scsi_qla_host
*ha
= (struct scsi_qla_host
*)host
->hostdata
;
4870 #if LINUX_VERSION_CODE >= 0x020600
4871 scsi_remove_host(host
);
4874 WRT_REG_WORD(&ha
->iobase
->ictrl
, 0);
4876 free_irq(pdev
->irq
, ha
);
4878 #if MEMORY_MAPPED_IO
4879 iounmap(ha
->mmpbase
);
4881 release_region(host
->io_port
, 0xff);
4884 pci_free_consistent(ha
->pdev
,
4885 ((REQUEST_ENTRY_CNT
+ 1) * (sizeof(request_t
))),
4886 ha
->request_ring
, ha
->request_dma
);
4887 pci_free_consistent(ha
->pdev
,
4888 ((RESPONSE_ENTRY_CNT
+ 1) * (sizeof(struct response
))),
4889 ha
->response_ring
, ha
->response_dma
);
4891 pci_disable_device(pdev
);
4893 scsi_host_put(host
);
4896 #if LINUX_VERSION_CODE >= 0x020600
4897 static struct pci_driver qla1280_pci_driver
= {
4899 .id_table
= qla1280_pci_tbl
,
4900 .probe
= qla1280_probe_one
,
4901 .remove
= __devexit_p(qla1280_remove_one
),
4907 if (sizeof(struct srb
) > sizeof(struct scsi_pointer
)) {
4909 "qla1280: struct srb too big, aborting\n");
4915 * If we are called as a module, the qla1280 pointer may not be null
4916 * and it would point to our bootup string, just like on the lilo
4917 * command line. IF not NULL, then process this config string with
4921 * To add options at boot time add a line to your lilo.conf file like:
4922 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4923 * which will result in the first four devices on the first two
4924 * controllers being set to a tagged queue depth of 32.
4927 qla1280_setup(qla1280
);
4930 return pci_module_init(&qla1280_pci_driver
);
4936 pci_unregister_driver(&qla1280_pci_driver
);
4939 module_init(qla1280_init
);
4940 module_exit(qla1280_exit
);
4943 # define driver_template qla1280_driver_template
4944 # include "scsi_module.c"
4947 MODULE_AUTHOR("Qlogic & Jes Sorensen");
4948 MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4949 MODULE_LICENSE("GPL");
4950 MODULE_VERSION(QLA1280_VERSION
);
4953 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4954 * Emacs will notice this stuff at the end of the file and automatically
4955 * adjust the settings for this buffer only. This must remain at the end
4957 * ---------------------------------------------------------------------------