/drivers/scsi/qla1280.c
C | 4504 lines | 2804 code | 634 blank | 1066 comment | 414 complexity | 28cf0447a57ce1a5edb885a2ef69de56 MD5 | raw file
Possible License(s): CC-BY-SA-3.0, GPL-2.0, LGPL-2.0, AGPL-1.0
Large files files are truncated, but you can click here to view the full file
1/******************************************************************************
2* QLOGIC LINUX SOFTWARE
3*
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
8*
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
12* later version.
13*
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.
18*
19******************************************************************************/
20#define QLA1280_VERSION "3.27.1"
21/*****************************************************************************
22 Revision History:
23 Rev 3.27.1, February 8, 2010, Michael Reed
24 - Retain firmware image for error recovery.
25 Rev 3.27, February 10, 2009, Michael Reed
26 - General code cleanup.
27 - Improve error recovery.
28 Rev 3.26, January 16, 2006 Jes Sorensen
29 - Ditch all < 2.6 support
30 Rev 3.25.1, February 10, 2005 Christoph Hellwig
31 - use pci_map_single to map non-S/G requests
32 - remove qla1280_proc_info
33 Rev 3.25, September 28, 2004, Christoph Hellwig
34 - add support for ISP1020/1040
35 - don't include "scsi.h" anymore for 2.6.x
36 Rev 3.24.4 June 7, 2004 Christoph Hellwig
37 - restructure firmware loading, cleanup initialization code
38 - prepare support for ISP1020/1040 chips
39 Rev 3.24.3 January 19, 2004, Jes Sorensen
40 - Handle PCI DMA mask settings correctly
41 - Correct order of error handling in probe_one, free_irq should not
42 be called if request_irq failed
43 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
44 - Big endian fixes (James)
45 - Remove bogus IOCB content on zero data transfer commands (Andrew)
46 Rev 3.24.1 January 5, 2004, Jes Sorensen
47 - Initialize completion queue to avoid OOPS on probe
48 - Handle interrupts during mailbox testing
49 Rev 3.24 November 17, 2003, Christoph Hellwig
50 - use struct list_head for completion queue
51 - avoid old Scsi_FOO typedefs
52 - cleanup 2.4 compat glue a bit
53 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
54 - make initialization for memory mapped vs port I/O more similar
55 - remove broken pci config space manipulation
56 - kill more cruft
57 - this is an almost perfect 2.6 scsi driver now! ;)
58 Rev 3.23.39 December 17, 2003, Jes Sorensen
59 - Delete completion queue from srb if mailbox command failed to
60 to avoid qla1280_done completeting qla1280_error_action's
61 obsolete context
62 - Reduce arguments for qla1280_done
63 Rev 3.23.38 October 18, 2003, Christoph Hellwig
64 - Convert to new-style hotplugable driver for 2.6
65 - Fix missing scsi_unregister/scsi_host_put on HBA removal
66 - Kill some more cruft
67 Rev 3.23.37 October 1, 2003, Jes Sorensen
68 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
69 random CONFIG option
70 - Clean up locking in probe path
71 Rev 3.23.36 October 1, 2003, Christoph Hellwig
72 - queuecommand only ever receives new commands - clear flags
73 - Reintegrate lost fixes from Linux 2.5
74 Rev 3.23.35 August 14, 2003, Jes Sorensen
75 - Build against 2.6
76 Rev 3.23.34 July 23, 2003, Jes Sorensen
77 - Remove pointless TRUE/FALSE macros
78 - Clean up vchan handling
79 Rev 3.23.33 July 3, 2003, Jes Sorensen
80 - Don't define register access macros before define determining MMIO.
81 This just happend to work out on ia64 but not elsewhere.
82 - Don't try and read from the card while it is in reset as
83 it won't respond and causes an MCA
84 Rev 3.23.32 June 23, 2003, Jes Sorensen
85 - Basic support for boot time arguments
86 Rev 3.23.31 June 8, 2003, Jes Sorensen
87 - Reduce boot time messages
88 Rev 3.23.30 June 6, 2003, Jes Sorensen
89 - Do not enable sync/wide/ppr before it has been determined
90 that the target device actually supports it
91 - Enable DMA arbitration for multi channel controllers
92 Rev 3.23.29 June 3, 2003, Jes Sorensen
93 - Port to 2.5.69
94 Rev 3.23.28 June 3, 2003, Jes Sorensen
95 - Eliminate duplicate marker commands on bus resets
96 - Handle outstanding commands appropriately on bus/device resets
97 Rev 3.23.27 May 28, 2003, Jes Sorensen
98 - Remove bogus input queue code, let the Linux SCSI layer do the work
99 - Clean up NVRAM handling, only read it once from the card
100 - Add a number of missing default nvram parameters
101 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
102 - Use completion queue for mailbox commands instead of busy wait
103 Rev 3.23.25 Beta May 27, 2003, James Bottomley
104 - Migrate to use new error handling code
105 Rev 3.23.24 Beta May 21, 2003, James Bottomley
106 - Big endian support
107 - Cleanup data direction code
108 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
109 - Switch to using MMIO instead of PIO
110 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
111 - Fix PCI parity problem with 12160 during reset.
112 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
113 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
114 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
115 - Remove < 2.4.x support
116 - Introduce HOST_LOCK to make the spin lock changes portable.
117 - Remove a bunch of idiotic and unnecessary typedef's
118 - Kill all leftovers of target-mode support which never worked anyway
119 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
120 - Do qla1280_pci_config() before calling request_irq() and
121 request_region()
122 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
123 of large shifts
124 - Hand correct arguments to free_irq() in case of failure
125 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
126 - Run source through Lindent and clean up the output
127 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
128 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
129 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
130 - Rely on mailbox commands generating interrupts - do not
131 run qla1280_isr() from ql1280_mailbox_command()
132 - Remove device_reg_t
133 - Integrate ql12160_set_target_parameters() with 1280 version
134 - Make qla1280_setup() non static
135 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
136 sent to the card - this command pauses the firmware!!!
137 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
138 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
139 - Remove a pile of pointless and confusing (srb_t **) and
140 (scsi_lu_t *) typecasts
141 - Explicit mark that we do not use the new error handling (for now)
142 - Remove scsi_qla_host_t and use 'struct' instead
143 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
144 pci_64bit_slot flags which weren't used for anything anyway
145 - Grab host->host_lock while calling qla1280_isr() from abort()
146 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
147 do not need to save/restore flags in the interrupt handler
148 - Enable interrupts early (before any mailbox access) in preparation
149 for cleaning up the mailbox handling
150 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
151 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
152 it with proper use of dprintk().
153 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
154 a debug level argument to determine if data is to be printed
155 - Add KERN_* info to printk()
156 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
157 - Significant cosmetic cleanups
158 - Change debug code to use dprintk() and remove #if mess
159 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
160 - More cosmetic cleanups, fix places treating return as function
161 - use cpu_relax() in qla1280_debounce_register()
162 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
163 - Make it compile under 2.5.5
164 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
165 - Do no typecast short * to long * in QL1280BoardTbl, this
166 broke miserably on big endian boxes
167 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
168 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
169 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
170 unsigned int to match the types from struct scsi_cmnd
171 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
172 - Remove bogus timer_t typedef from qla1280.h
173 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
174 for PCI_ values, call pci_set_master()
175 - Fix memleak of qla1280_buffer on module unload
176 - Only compile module parsing code #ifdef MODULE - should be
177 changed to use individual MODULE_PARM's later
178 - Remove dummy_buffer that was never modified nor printed
179 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
180 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
181 - Remove \r from print statements, this is Linux, not DOS
182 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
183 dummy macros
184 - Remove C++ compile hack in header file as Linux driver are not
185 supposed to be compiled as C++
186 - Kill MS_64BITS macro as it makes the code more readable
187 - Remove unnecessary flags.in_interrupts bit
188 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
189 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
190 - Check whether the interrupt was generated by the QLA1280 before
191 doing any processing
192 - qla1280_status_entry(): Only zero out part of sense_buffer that
193 is not being copied into
194 - Remove more superflouous typecasts
195 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
196 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
197 - Don't walk the entire list in qla1280_putq_t() just to directly
198 grab the pointer to the last element afterwards
199 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
200 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
201 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
202 - Set dev->max_sectors to 1024
203 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
204 - Provide compat macros for pci_enable_device(), pci_find_subsys()
205 and scsi_set_pci_device()
206 - Call scsi_set_pci_device() for all devices
207 - Reduce size of kernel version dependent device probe code
208 - Move duplicate probe/init code to separate function
209 - Handle error if qla1280_mem_alloc() fails
210 - Kill OFFSET() macro and use Linux's PCI definitions instead
211 - Kill private structure defining PCI config space (struct config_reg)
212 - Only allocate I/O port region if not in MMIO mode
213 - Remove duplicate (unused) sanity check of sife of srb_t
214 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
215 - Change home-brew memset() implementations to use memset()
216 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
217 port directly is not legal under Linux.
218 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
219 - Remove pre 2.2 kernel support
220 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
221 - Fix MMIO access to use readl/writel instead of directly
222 dereferencing pointers
223 - Nuke MSDOS debugging code
224 - Change true/false data types to int from uint8_t
225 - Use int for counters instead of uint8_t etc.
226 - Clean up size & byte order conversion macro usage
227 Rev 3.23 Beta January 11, 2001 BN Qlogic
228 - Added check of device_id when handling non
229 QLA12160s during detect().
230 Rev 3.22 Beta January 5, 2001 BN Qlogic
231 - Changed queue_task() to schedule_task()
232 for kernels 2.4.0 and higher.
233 Note: 2.4.0-testxx kernels released prior to
234 the actual 2.4.0 kernel release on January 2001
235 will get compile/link errors with schedule_task().
236 Please update your kernel to released 2.4.0 level,
237 or comment lines in this file flagged with 3.22
238 to resolve compile/link error of schedule_task().
239 - Added -DCONFIG_SMP in addition to -D__SMP__
240 in Makefile for 2.4.0 builds of driver as module.
241 Rev 3.21 Beta January 4, 2001 BN Qlogic
242 - Changed criteria of 64/32 Bit mode of HBA
243 operation according to BITS_PER_LONG rather
244 than HBA's NVRAM setting of >4Gig memory bit;
245 so that the HBA auto-configures without the need
246 to setup each system individually.
247 Rev 3.20 Beta December 5, 2000 BN Qlogic
248 - Added priority handling to IA-64 onboard SCSI
249 ISP12160 chip for kernels greater than 2.3.18.
250 - Added irqrestore for qla1280_intr_handler.
251 - Enabled /proc/scsi/qla1280 interface.
252 - Clear /proc/scsi/qla1280 counters in detect().
253 Rev 3.19 Beta October 13, 2000 BN Qlogic
254 - Declare driver_template for new kernel
255 (2.4.0 and greater) scsi initialization scheme.
256 - Update /proc/scsi entry for 2.3.18 kernels and
257 above as qla1280
258 Rev 3.18 Beta October 10, 2000 BN Qlogic
259 - Changed scan order of adapters to map
260 the QLA12160 followed by the QLA1280.
261 Rev 3.17 Beta September 18, 2000 BN Qlogic
262 - Removed warnings for 32 bit 2.4.x compiles
263 - Corrected declared size for request and response
264 DMA addresses that are kept in each ha
265 Rev. 3.16 Beta August 25, 2000 BN Qlogic
266 - Corrected 64 bit addressing issue on IA-64
267 where the upper 32 bits were not properly
268 passed to the RISC engine.
269 Rev. 3.15 Beta August 22, 2000 BN Qlogic
270 - Modified qla1280_setup_chip to properly load
271 ISP firmware for greater that 4 Gig memory on IA-64
272 Rev. 3.14 Beta August 16, 2000 BN Qlogic
273 - Added setting of dma_mask to full 64 bit
274 if flags.enable_64bit_addressing is set in NVRAM
275 Rev. 3.13 Beta August 16, 2000 BN Qlogic
276 - Use new PCI DMA mapping APIs for 2.4.x kernel
277 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
278 - Added check of pci_enable_device to detect() for 2.3.x
279 - Use pci_resource_start() instead of
280 pdev->resource[0].start in detect() for 2.3.x
281 - Updated driver version
282 Rev. 3.11 July 14, 2000 BN Qlogic
283 - Updated SCSI Firmware to following versions:
284 qla1x80: 8.13.08
285 qla1x160: 10.04.08
286 - Updated driver version to 3.11
287 Rev. 3.10 June 23, 2000 BN Qlogic
288 - Added filtering of AMI SubSys Vendor ID devices
289 Rev. 3.9
290 - DEBUG_QLA1280 undefined and new version BN Qlogic
291 Rev. 3.08b May 9, 2000 MD Dell
292 - Added logic to check against AMI subsystem vendor ID
293 Rev. 3.08 May 4, 2000 DG Qlogic
294 - Added logic to check for PCI subsystem ID.
295 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
296 - Updated SCSI Firmware to following versions:
297 qla12160: 10.01.19
298 qla1280: 8.09.00
299 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
300 - Internal revision; not released
301 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
302 - Edit correction for virt_to_bus and PROC.
303 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
304 - Merge changes from ia64 port.
305 Rev. 3.03 Mar 28, 2000 BN Qlogic
306 - Increase version to reflect new code drop with compile fix
307 of issue with inclusion of linux/spinlock for 2.3 kernels
308 Rev. 3.02 Mar 15, 2000 BN Qlogic
309 - Merge qla1280_proc_info from 2.10 code base
310 Rev. 3.01 Feb 10, 2000 BN Qlogic
311 - Corrected code to compile on a 2.2.x kernel.
312 Rev. 3.00 Jan 17, 2000 DG Qlogic
313 - Added 64-bit support.
314 Rev. 2.07 Nov 9, 1999 DG Qlogic
315 - Added new routine to set target parameters for ISP12160.
316 Rev. 2.06 Sept 10, 1999 DG Qlogic
317 - Added support for ISP12160 Ultra 3 chip.
318 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
319 - Modified code to remove errors generated when compiling with
320 Cygnus IA64 Compiler.
321 - Changed conversion of pointers to unsigned longs instead of integers.
322 - Changed type of I/O port variables from uint32_t to unsigned long.
323 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
324 - Changed sprintf and printk format specifiers for pointers to %p.
325 - Changed some int to long type casts where needed in sprintf & printk.
326 - Added l modifiers to sprintf and printk format specifiers for longs.
327 - Removed unused local variables.
328 Rev. 1.20 June 8, 1999 DG, Qlogic
329 Changes to support RedHat release 6.0 (kernel 2.2.5).
330 - Added SCSI exclusive access lock (io_request_lock) when accessing
331 the adapter.
332 - Added changes for the new LINUX interface template. Some new error
333 handling routines have been added to the template, but for now we
334 will use the old ones.
335 - Initial Beta Release.
336*****************************************************************************/
337
338
339#include <linux/module.h>
340
341#include <linux/types.h>
342#include <linux/string.h>
343#include <linux/errno.h>
344#include <linux/kernel.h>
345#include <linux/ioport.h>
346#include <linux/delay.h>
347#include <linux/timer.h>
348#include <linux/pci.h>
349#include <linux/proc_fs.h>
350#include <linux/stat.h>
351#include <linux/pci_ids.h>
352#include <linux/interrupt.h>
353#include <linux/init.h>
354#include <linux/dma-mapping.h>
355#include <linux/firmware.h>
356
357#include <asm/io.h>
358#include <asm/irq.h>
359#include <asm/byteorder.h>
360#include <asm/processor.h>
361#include <asm/types.h>
362#include <asm/system.h>
363
364#include <scsi/scsi.h>
365#include <scsi/scsi_cmnd.h>
366#include <scsi/scsi_device.h>
367#include <scsi/scsi_host.h>
368#include <scsi/scsi_tcq.h>
369
370#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
371#include <asm/sn/io.h>
372#endif
373
374
375/*
376 * Compile time Options:
377 * 0 - Disable and 1 - Enable
378 */
379#define DEBUG_QLA1280_INTR 0
380#define DEBUG_PRINT_NVRAM 0
381#define DEBUG_QLA1280 0
382
383/*
384 * The SGI VISWS is broken and doesn't support MMIO ;-(
385 */
386#ifdef CONFIG_X86_VISWS
387#define MEMORY_MAPPED_IO 0
388#else
389#define MEMORY_MAPPED_IO 1
390#endif
391
392#include "qla1280.h"
393
394#ifndef BITS_PER_LONG
395#error "BITS_PER_LONG not defined!"
396#endif
397#if (BITS_PER_LONG == 64) || defined CONFIG_HIGHMEM
398#define QLA_64BIT_PTR 1
399#endif
400
401#ifdef QLA_64BIT_PTR
402#define pci_dma_hi32(a) ((a >> 16) >> 16)
403#else
404#define pci_dma_hi32(a) 0
405#endif
406#define pci_dma_lo32(a) (a & 0xffffffff)
407
408#define NVRAM_DELAY() udelay(500) /* 2 microseconds */
409
410#if defined(__ia64__) && !defined(ia64_platform_is)
411#define ia64_platform_is(foo) (!strcmp(x, platform_name))
412#endif
413
414
415#define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
416#define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
417 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
418#define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
419 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
420
421
422static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
423static void qla1280_remove_one(struct pci_dev *);
424
425/*
426 * QLogic Driver Support Function Prototypes.
427 */
428static void qla1280_done(struct scsi_qla_host *);
429static int qla1280_get_token(char *);
430static int qla1280_setup(char *s) __init;
431
432/*
433 * QLogic ISP1280 Hardware Support Function Prototypes.
434 */
435static int qla1280_load_firmware(struct scsi_qla_host *);
436static int qla1280_init_rings(struct scsi_qla_host *);
437static int qla1280_nvram_config(struct scsi_qla_host *);
438static int qla1280_mailbox_command(struct scsi_qla_host *,
439 uint8_t, uint16_t *);
440static int qla1280_bus_reset(struct scsi_qla_host *, int);
441static int qla1280_device_reset(struct scsi_qla_host *, int, int);
442static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
443static int qla1280_abort_isp(struct scsi_qla_host *);
444#ifdef QLA_64BIT_PTR
445static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
446#else
447static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
448#endif
449static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
450static void qla1280_poll(struct scsi_qla_host *);
451static void qla1280_reset_adapter(struct scsi_qla_host *);
452static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
453static void qla1280_isp_cmd(struct scsi_qla_host *);
454static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
455static void qla1280_rst_aen(struct scsi_qla_host *);
456static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
457 struct list_head *);
458static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
459 struct list_head *);
460static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
461static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
462static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
463static request_t *qla1280_req_pkt(struct scsi_qla_host *);
464static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
465 unsigned int);
466static void qla1280_get_target_parameters(struct scsi_qla_host *,
467 struct scsi_device *);
468static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
469
470
471static struct qla_driver_setup driver_setup;
472
473/*
474 * convert scsi data direction to request_t control flags
475 */
476static inline uint16_t
477qla1280_data_direction(struct scsi_cmnd *cmnd)
478{
479 switch(cmnd->sc_data_direction) {
480 case DMA_FROM_DEVICE:
481 return BIT_5;
482 case DMA_TO_DEVICE:
483 return BIT_6;
484 case DMA_BIDIRECTIONAL:
485 return BIT_5 | BIT_6;
486 /*
487 * We could BUG() on default here if one of the four cases aren't
488 * met, but then again if we receive something like that from the
489 * SCSI layer we have more serious problems. This shuts up GCC.
490 */
491 case DMA_NONE:
492 default:
493 return 0;
494 }
495}
496
497#if DEBUG_QLA1280
498static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
499static void __qla1280_dump_buffer(char *, int);
500#endif
501
502
503/*
504 * insmod needs to find the variable and make it point to something
505 */
506#ifdef MODULE
507static char *qla1280;
508
509/* insmod qla1280 options=verbose" */
510module_param(qla1280, charp, 0);
511#else
512__setup("qla1280=", qla1280_setup);
513#endif
514
515
516/*
517 * We use the scsi_pointer structure that's included with each scsi_command
518 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
519 * bigger than a scsi_pointer.
520 */
521
522#define CMD_SP(Cmnd) &Cmnd->SCp
523#define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
524#define CMD_CDBP(Cmnd) Cmnd->cmnd
525#define CMD_SNSP(Cmnd) Cmnd->sense_buffer
526#define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
527#define CMD_RESULT(Cmnd) Cmnd->result
528#define CMD_HANDLE(Cmnd) Cmnd->host_scribble
529#define CMD_REQUEST(Cmnd) Cmnd->request->cmd
530
531#define CMD_HOST(Cmnd) Cmnd->device->host
532#define SCSI_BUS_32(Cmnd) Cmnd->device->channel
533#define SCSI_TCN_32(Cmnd) Cmnd->device->id
534#define SCSI_LUN_32(Cmnd) Cmnd->device->lun
535
536
537/*****************************************/
538/* ISP Boards supported by this driver */
539/*****************************************/
540
541struct qla_boards {
542 char *name; /* Board ID String */
543 int numPorts; /* Number of SCSI ports */
544 int fw_index; /* index into qla1280_fw_tbl for firmware */
545};
546
547/* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
548static struct pci_device_id qla1280_pci_tbl[] = {
549 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
550 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
551 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
552 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
553 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
554 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
555 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
556 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
557 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
558 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
559 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
560 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
561 {0,}
562};
563MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
564
565DEFINE_MUTEX(qla1280_firmware_mutex);
566
567struct qla_fw {
568 char *fwname;
569 const struct firmware *fw;
570};
571
572#define QL_NUM_FW_IMAGES 3
573
574struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
575 {"qlogic/1040.bin", NULL}, /* image 0 */
576 {"qlogic/1280.bin", NULL}, /* image 1 */
577 {"qlogic/12160.bin", NULL}, /* image 2 */
578};
579
580/* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
581static struct qla_boards ql1280_board_tbl[] = {
582 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
583 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
584 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
585 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
586 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
587 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
588 {.name = " ", .numPorts = 0, .fw_index = -1},
589};
590
591static int qla1280_verbose = 1;
592
593#if DEBUG_QLA1280
594static int ql_debug_level = 1;
595#define dprintk(level, format, a...) \
596 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
597#define qla1280_dump_buffer(level, buf, size) \
598 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
599#define qla1280_print_scsi_cmd(level, cmd) \
600 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
601#else
602#define ql_debug_level 0
603#define dprintk(level, format, a...) do{}while(0)
604#define qla1280_dump_buffer(a, b, c) do{}while(0)
605#define qla1280_print_scsi_cmd(a, b) do{}while(0)
606#endif
607
608#define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
609#define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
610#define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
611#define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
612
613
614static int qla1280_read_nvram(struct scsi_qla_host *ha)
615{
616 uint16_t *wptr;
617 uint8_t chksum;
618 int cnt, i;
619 struct nvram *nv;
620
621 ENTER("qla1280_read_nvram");
622
623 if (driver_setup.no_nvram)
624 return 1;
625
626 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
627
628 wptr = (uint16_t *)&ha->nvram;
629 nv = &ha->nvram;
630 chksum = 0;
631 for (cnt = 0; cnt < 3; cnt++) {
632 *wptr = qla1280_get_nvram_word(ha, cnt);
633 chksum += *wptr & 0xff;
634 chksum += (*wptr >> 8) & 0xff;
635 wptr++;
636 }
637
638 if (nv->id0 != 'I' || nv->id1 != 'S' ||
639 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
640 dprintk(2, "Invalid nvram ID or version!\n");
641 chksum = 1;
642 } else {
643 for (; cnt < sizeof(struct nvram); cnt++) {
644 *wptr = qla1280_get_nvram_word(ha, cnt);
645 chksum += *wptr & 0xff;
646 chksum += (*wptr >> 8) & 0xff;
647 wptr++;
648 }
649 }
650
651 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
652 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
653 nv->version);
654
655
656 if (chksum) {
657 if (!driver_setup.no_nvram)
658 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
659 "validate NVRAM checksum, using default "
660 "settings\n", ha->host_no);
661 ha->nvram_valid = 0;
662 } else
663 ha->nvram_valid = 1;
664
665 /* The firmware interface is, um, interesting, in that the
666 * actual firmware image on the chip is little endian, thus,
667 * the process of taking that image to the CPU would end up
668 * little endian. However, the firmware interface requires it
669 * to be read a word (two bytes) at a time.
670 *
671 * The net result of this would be that the word (and
672 * doubleword) quantites in the firmware would be correct, but
673 * the bytes would be pairwise reversed. Since most of the
674 * firmware quantites are, in fact, bytes, we do an extra
675 * le16_to_cpu() in the firmware read routine.
676 *
677 * The upshot of all this is that the bytes in the firmware
678 * are in the correct places, but the 16 and 32 bit quantites
679 * are still in little endian format. We fix that up below by
680 * doing extra reverses on them */
681 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
682 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
683 for(i = 0; i < MAX_BUSES; i++) {
684 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
685 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
686 }
687 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
688 LEAVE("qla1280_read_nvram");
689
690 return chksum;
691}
692
693/**************************************************************************
694 * qla1280_info
695 * Return a string describing the driver.
696 **************************************************************************/
697static const char *
698qla1280_info(struct Scsi_Host *host)
699{
700 static char qla1280_scsi_name_buffer[125];
701 char *bp;
702 struct scsi_qla_host *ha;
703 struct qla_boards *bdp;
704
705 bp = &qla1280_scsi_name_buffer[0];
706 ha = (struct scsi_qla_host *)host->hostdata;
707 bdp = &ql1280_board_tbl[ha->devnum];
708 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
709
710 sprintf (bp,
711 "QLogic %s PCI to SCSI Host Adapter\n"
712 " Firmware version: %2d.%02d.%02d, Driver version %s",
713 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
714 QLA1280_VERSION);
715 return bp;
716}
717
718/**************************************************************************
719 * qla1280_queuecommand
720 * Queue a command to the controller.
721 *
722 * Note:
723 * The mid-level driver tries to ensures that queuecommand never gets invoked
724 * concurrently with itself or the interrupt handler (although the
725 * interrupt handler may call this routine as part of request-completion
726 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
727 * context which is a big NO! NO!.
728 **************************************************************************/
729static int
730qla1280_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
731{
732 struct Scsi_Host *host = cmd->device->host;
733 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
734 struct srb *sp = (struct srb *)CMD_SP(cmd);
735 int status;
736
737 cmd->scsi_done = fn;
738 sp->cmd = cmd;
739 sp->flags = 0;
740 sp->wait = NULL;
741 CMD_HANDLE(cmd) = (unsigned char *)NULL;
742
743 qla1280_print_scsi_cmd(5, cmd);
744
745#ifdef QLA_64BIT_PTR
746 /*
747 * Using 64 bit commands if the PCI bridge doesn't support it is a
748 * bit wasteful, however this should really only happen if one's
749 * PCI controller is completely broken, like the BCM1250. For
750 * sane hardware this is not an issue.
751 */
752 status = qla1280_64bit_start_scsi(ha, sp);
753#else
754 status = qla1280_32bit_start_scsi(ha, sp);
755#endif
756 return status;
757}
758
759enum action {
760 ABORT_COMMAND,
761 DEVICE_RESET,
762 BUS_RESET,
763 ADAPTER_RESET,
764};
765
766
767static void qla1280_mailbox_timeout(unsigned long __data)
768{
769 struct scsi_qla_host *ha = (struct scsi_qla_host *)__data;
770 struct device_reg __iomem *reg;
771 reg = ha->iobase;
772
773 ha->mailbox_out[0] = RD_REG_WORD(®->mailbox0);
774 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
775 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
776 RD_REG_WORD(®->ictrl), RD_REG_WORD(®->istatus));
777 complete(ha->mailbox_wait);
778}
779
780static int
781_qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
782 struct completion *wait)
783{
784 int status = FAILED;
785 struct scsi_cmnd *cmd = sp->cmd;
786
787 spin_unlock_irq(ha->host->host_lock);
788 wait_for_completion_timeout(wait, 4*HZ);
789 spin_lock_irq(ha->host->host_lock);
790 sp->wait = NULL;
791 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
792 status = SUCCESS;
793 (*cmd->scsi_done)(cmd);
794 }
795 return status;
796}
797
798static int
799qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
800{
801 DECLARE_COMPLETION_ONSTACK(wait);
802
803 sp->wait = &wait;
804 return _qla1280_wait_for_single_command(ha, sp, &wait);
805}
806
807static int
808qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
809{
810 int cnt;
811 int status;
812 struct srb *sp;
813 struct scsi_cmnd *cmd;
814
815 status = SUCCESS;
816
817 /*
818 * Wait for all commands with the designated bus/target
819 * to be completed by the firmware
820 */
821 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
822 sp = ha->outstanding_cmds[cnt];
823 if (sp) {
824 cmd = sp->cmd;
825
826 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
827 continue;
828 if (target >= 0 && SCSI_TCN_32(cmd) != target)
829 continue;
830
831 status = qla1280_wait_for_single_command(ha, sp);
832 if (status == FAILED)
833 break;
834 }
835 }
836 return status;
837}
838
839/**************************************************************************
840 * qla1280_error_action
841 * The function will attempt to perform a specified error action and
842 * wait for the results (or time out).
843 *
844 * Input:
845 * cmd = Linux SCSI command packet of the command that cause the
846 * bus reset.
847 * action = error action to take (see action_t)
848 *
849 * Returns:
850 * SUCCESS or FAILED
851 *
852 **************************************************************************/
853static int
854qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
855{
856 struct scsi_qla_host *ha;
857 int bus, target, lun;
858 struct srb *sp;
859 int i, found;
860 int result=FAILED;
861 int wait_for_bus=-1;
862 int wait_for_target = -1;
863 DECLARE_COMPLETION_ONSTACK(wait);
864
865 ENTER("qla1280_error_action");
866
867 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
868 sp = (struct srb *)CMD_SP(cmd);
869 bus = SCSI_BUS_32(cmd);
870 target = SCSI_TCN_32(cmd);
871 lun = SCSI_LUN_32(cmd);
872
873 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
874 RD_REG_WORD(&ha->iobase->istatus));
875
876 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
877 RD_REG_WORD(&ha->iobase->host_cmd),
878 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
879
880 if (qla1280_verbose)
881 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
882 "Handle=0x%p, action=0x%x\n",
883 ha->host_no, cmd, CMD_HANDLE(cmd), action);
884
885 /*
886 * Check to see if we have the command in the outstanding_cmds[]
887 * array. If not then it must have completed before this error
888 * action was initiated. If the error_action isn't ABORT_COMMAND
889 * then the driver must proceed with the requested action.
890 */
891 found = -1;
892 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
893 if (sp == ha->outstanding_cmds[i]) {
894 found = i;
895 sp->wait = &wait; /* we'll wait for it to complete */
896 break;
897 }
898 }
899
900 if (found < 0) { /* driver doesn't have command */
901 result = SUCCESS;
902 if (qla1280_verbose) {
903 printk(KERN_INFO
904 "scsi(%ld:%d:%d:%d): specified command has "
905 "already completed.\n", ha->host_no, bus,
906 target, lun);
907 }
908 }
909
910 switch (action) {
911
912 case ABORT_COMMAND:
913 dprintk(1, "qla1280: RISC aborting command\n");
914 /*
915 * The abort might fail due to race when the host_lock
916 * is released to issue the abort. As such, we
917 * don't bother to check the return status.
918 */
919 if (found >= 0)
920 qla1280_abort_command(ha, sp, found);
921 break;
922
923 case DEVICE_RESET:
924 if (qla1280_verbose)
925 printk(KERN_INFO
926 "scsi(%ld:%d:%d:%d): Queueing device reset "
927 "command.\n", ha->host_no, bus, target, lun);
928 if (qla1280_device_reset(ha, bus, target) == 0) {
929 /* issued device reset, set wait conditions */
930 wait_for_bus = bus;
931 wait_for_target = target;
932 }
933 break;
934
935 case BUS_RESET:
936 if (qla1280_verbose)
937 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
938 "reset.\n", ha->host_no, bus);
939 if (qla1280_bus_reset(ha, bus) == 0) {
940 /* issued bus reset, set wait conditions */
941 wait_for_bus = bus;
942 }
943 break;
944
945 case ADAPTER_RESET:
946 default:
947 if (qla1280_verbose) {
948 printk(KERN_INFO
949 "scsi(%ld): Issued ADAPTER RESET\n",
950 ha->host_no);
951 printk(KERN_INFO "scsi(%ld): I/O processing will "
952 "continue automatically\n", ha->host_no);
953 }
954 ha->flags.reset_active = 1;
955
956 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
957 result = FAILED;
958 }
959
960 ha->flags.reset_active = 0;
961 }
962
963 /*
964 * At this point, the host_lock has been released and retaken
965 * by the issuance of the mailbox command.
966 * Wait for the command passed in by the mid-layer if it
967 * was found by the driver. It might have been returned
968 * between eh recovery steps, hence the check of the "found"
969 * variable.
970 */
971
972 if (found >= 0)
973 result = _qla1280_wait_for_single_command(ha, sp, &wait);
974
975 if (action == ABORT_COMMAND && result != SUCCESS) {
976 printk(KERN_WARNING
977 "scsi(%li:%i:%i:%i): "
978 "Unable to abort command!\n",
979 ha->host_no, bus, target, lun);
980 }
981
982 /*
983 * If the command passed in by the mid-layer has been
984 * returned by the board, then wait for any additional
985 * commands which are supposed to complete based upon
986 * the error action.
987 *
988 * All commands are unconditionally returned during a
989 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
990 * to wait for them.
991 */
992 if (result == SUCCESS && wait_for_bus >= 0) {
993 result = qla1280_wait_for_pending_commands(ha,
994 wait_for_bus, wait_for_target);
995 }
996
997 dprintk(1, "RESET returning %d\n", result);
998
999 LEAVE("qla1280_error_action");
1000 return result;
1001}
1002
1003/**************************************************************************
1004 * qla1280_abort
1005 * Abort the specified SCSI command(s).
1006 **************************************************************************/
1007static int
1008qla1280_eh_abort(struct scsi_cmnd * cmd)
1009{
1010 int rc;
1011
1012 spin_lock_irq(cmd->device->host->host_lock);
1013 rc = qla1280_error_action(cmd, ABORT_COMMAND);
1014 spin_unlock_irq(cmd->device->host->host_lock);
1015
1016 return rc;
1017}
1018
1019/**************************************************************************
1020 * qla1280_device_reset
1021 * Reset the specified SCSI device
1022 **************************************************************************/
1023static int
1024qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1025{
1026 int rc;
1027
1028 spin_lock_irq(cmd->device->host->host_lock);
1029 rc = qla1280_error_action(cmd, DEVICE_RESET);
1030 spin_unlock_irq(cmd->device->host->host_lock);
1031
1032 return rc;
1033}
1034
1035/**************************************************************************
1036 * qla1280_bus_reset
1037 * Reset the specified bus.
1038 **************************************************************************/
1039static int
1040qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1041{
1042 int rc;
1043
1044 spin_lock_irq(cmd->device->host->host_lock);
1045 rc = qla1280_error_action(cmd, BUS_RESET);
1046 spin_unlock_irq(cmd->device->host->host_lock);
1047
1048 return rc;
1049}
1050
1051/**************************************************************************
1052 * qla1280_adapter_reset
1053 * Reset the specified adapter (both channels)
1054 **************************************************************************/
1055static int
1056qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1057{
1058 int rc;
1059
1060 spin_lock_irq(cmd->device->host->host_lock);
1061 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1062 spin_unlock_irq(cmd->device->host->host_lock);
1063
1064 return rc;
1065}
1066
1067static int
1068qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1069 sector_t capacity, int geom[])
1070{
1071 int heads, sectors, cylinders;
1072
1073 heads = 64;
1074 sectors = 32;
1075 cylinders = (unsigned long)capacity / (heads * sectors);
1076 if (cylinders > 1024) {
1077 heads = 255;
1078 sectors = 63;
1079 cylinders = (unsigned long)capacity / (heads * sectors);
1080 /* if (cylinders > 1023)
1081 cylinders = 1023; */
1082 }
1083
1084 geom[0] = heads;
1085 geom[1] = sectors;
1086 geom[2] = cylinders;
1087
1088 return 0;
1089}
1090
1091
1092/* disable risc and host interrupts */
1093static inline void
1094qla1280_disable_intrs(struct scsi_qla_host *ha)
1095{
1096 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1097 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1098}
1099
1100/* enable risc and host interrupts */
1101static inline void
1102qla1280_enable_intrs(struct scsi_qla_host *ha)
1103{
1104 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1105 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1106}
1107
1108/**************************************************************************
1109 * qla1280_intr_handler
1110 * Handles the H/W interrupt
1111 **************************************************************************/
1112static irqreturn_t
1113qla1280_intr_handler(int irq, void *dev_id)
1114{
1115 struct scsi_qla_host *ha;
1116 struct device_reg __iomem *reg;
1117 u16 data;
1118 int handled = 0;
1119
1120 ENTER_INTR ("qla1280_intr_handler");
1121 ha = (struct scsi_qla_host *)dev_id;
1122
1123 spin_lock(ha->host->host_lock);
1124
1125 ha->isr_count++;
1126 reg = ha->iobase;
1127
1128 qla1280_disable_intrs(ha);
1129
1130 data = qla1280_debounce_register(®->istatus);
1131 /* Check for pending interrupts. */
1132 if (data & RISC_INT) {
1133 qla1280_isr(ha, &ha->done_q);
1134 handled = 1;
1135 }
1136 if (!list_empty(&ha->done_q))
1137 qla1280_done(ha);
1138
1139 spin_unlock(ha->host->host_lock);
1140
1141 qla1280_enable_intrs(ha);
1142
1143 LEAVE_INTR("qla1280_intr_handler");
1144 return IRQ_RETVAL(handled);
1145}
1146
1147
1148static int
1149qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1150{
1151 uint8_t mr;
1152 uint16_t mb[MAILBOX_REGISTER_COUNT];
1153 struct nvram *nv;
1154 int status, lun;
1155
1156 nv = &ha->nvram;
1157
1158 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1159
1160 /* Set Target Parameters. */
1161 mb[0] = MBC_SET_TARGET_PARAMETERS;
1162 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1163 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1164 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1165 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1166 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1167 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1168 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1169 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1170 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1171
1172 if (IS_ISP1x160(ha)) {
1173 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1174 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1175 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1176 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1177 mr |= BIT_6;
1178 } else {
1179 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1180 }
1181 mb[3] |= nv->bus[bus].target[target].sync_period;
1182
1183 status = qla1280_mailbox_command(ha, mr, mb);
1184
1185 /* Set Device Queue Parameters. */
1186 for (lun = 0; lun < MAX_LUNS; lun++) {
1187 mb[0] = MBC_SET_DEVICE_QUEUE;
1188 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1189 mb[1] |= lun;
1190 mb[2] = nv->bus[bus].max_queue_depth;
1191 mb[3] = nv->bus[bus].target[target].execution_throttle;
1192 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1193 }
1194
1195 if (status)
1196 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1197 "qla1280_set_target_parameters() failed\n",
1198 ha->host_no, bus, target);
1199 return status;
1200}
1201
1202
1203/**************************************************************************
1204 * qla1280_slave_configure
1205 *
1206 * Description:
1207 * Determines the queue depth for a given device. There are two ways
1208 * a queue depth can be obtained for a tagged queueing device. One
1209 * way is the default queue depth which is determined by whether
1210 * If it is defined, then it is used
1211 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1212 * default queue depth (dependent on the number of hardware SCBs).
1213 **************************************************************************/
1214static int
1215qla1280_slave_configure(struct scsi_device *device)
1216{
1217 struct scsi_qla_host *ha;
1218 int default_depth = 3;
1219 int bus = device->channel;
1220 int target = device->id;
1221 int status = 0;
1222 struct nvram *nv;
1223 unsigned long flags;
1224
1225 ha = (struct scsi_qla_host *)device->host->hostdata;
1226 nv = &ha->nvram;
1227
1228 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1229 return 1;
1230
1231 if (device->tagged_supported &&
1232 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1233 scsi_adjust_queue_depth(device, MSG_ORDERED_TAG,
1234 ha->bus_settings[bus].hiwat);
1235 } else {
1236 scsi_adjust_queue_depth(device, 0, default_depth);
1237 }
1238
1239 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1240 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1241 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1242
1243 if (driver_setup.no_sync ||
1244 (driver_setup.sync_mask &&
1245 (~driver_setup.sync_mask & (1 << target))))
1246 nv->bus[bus].target[target].parameter.enable_sync = 0;
1247 if (driver_setup.no_wide ||
1248 (driver_setup.wide_mask &&
1249 (~driver_setup.wide_mask & (1 << target))))
1250 nv->bus[bus].target[target].parameter.enable_wide = 0;
1251 if (IS_ISP1x160(ha)) {
1252 if (driver_setup.no_ppr ||
1253 (driver_setup.ppr_mask &&
1254 (~driver_setup.ppr_mask & (1 << target))))
1255 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1256 }
1257
1258 spin_lock_irqsave(ha->host->host_lock, flags);
1259 if (nv->bus[bus].target[target].parameter.enable_sync)
1260 status = qla1280_set_target_parameters(ha, bus, target);
1261 qla1280_get_target_parameters(ha, device);
1262 spin_unlock_irqrestore(ha->host->host_lock, flags);
1263 return status;
1264}
1265
1266
1267/*
1268 * qla1280_done
1269 * Process completed commands.
1270 *
1271 * Input:
1272 * ha = adapter block pointer.
1273 */
1274static void
1275qla1280_done(struct scsi_qla_host *ha)
1276{
1277 struct srb *sp;
1278 struct list_head *done_q;
1279 int bus, target, lun;
1280 struct scsi_cmnd *cmd;
1281
1282 ENTER("qla1280_done");
1283
1284 done_q = &ha->done_q;
1285
1286 while (!list_empty(done_q)) {
1287 sp = list_entry(done_q->next, struct srb, list);
1288
1289 list_del(&sp->list);
1290
1291 cmd = sp->cmd;
1292 bus = SCSI_BUS_32(cmd);
1293 target = SCSI_TCN_32(cmd);
1294 lun = SCSI_LUN_32(cmd);
1295
1296 switch ((CMD_RESULT(cmd) >> 16)) {
1297 case DID_RESET:
1298 /* Issue marker command. */
1299 if (!ha->flags.abort_isp_active)
1300 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1301 break;
1302 case DID_ABORT:
1303 sp->flags &= ~SRB_ABORT_PENDING;
1304 sp->flags |= SRB_ABORTED;
1305 break;
1306 default:
1307 break;
1308 }
1309
1310 /* Release memory used for this I/O */
1311 scsi_dma_unmap(cmd);
1312
1313 /* Call the mid-level driver interrupt handler */
1314 ha->actthreads--;
1315
1316 if (sp->wait == NULL)
1317 (*(cmd)->scsi_done)(cmd);
1318 else
1319 complete(sp->wait);
1320 }
1321 LEAVE("qla1280_done");
1322}
1323
1324/*
1325 * Translates a ISP error to a Linux SCSI error
1326 */
1327static int
1328qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1329{
1330 int host_status = DID_ERROR;
1331 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1332 uint16_t state_flags = le16_to_cpu(sts->state_flags);
1333 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1334 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1335#if DEBUG_QLA1280_INTR
1336 static char *reason[] = {
1337 "DID_OK",
1338 "DID_NO_CONNECT",
1339 "DID_BUS_BUSY",
1340 "DID_TIME_OUT",
1341 "DID_BAD_TARGET",
1342 "DID_ABORT",
1343 "DID_PARITY",
1344 "DID_ERROR",
1345 "DID_RESET",
1346 "DID_BAD_INTR"
1347 };
1348#endif /* DEBUG_QLA1280_INTR */
1349
1350 ENTER("qla1280_return_status");
1351
1352#if DEBUG_QLA1280_INTR
1353 /*
1354 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1355 comp_status);
1356 */
1357#endif
1358
1359 switch (comp_status) {
1360 case CS_COMPLETE:
1361 host_status = DID_OK;
1362 break;
1363
1364 case CS_INCOMPLETE:
1365 if (!(state_flags & SF_GOT_BUS))
1366 host_status = DID_NO_CONNECT;
1367 else if (!(state_flags & SF_GOT_TARGET))
1368 host_status = DID_BAD_TARGET;
1369 else if (!(state_flags & SF_SENT_CDB))
1370 host_status = DID_ERROR;
1371 else if (!(state_flags & SF_TRANSFERRED_DATA))
1372 host_status = DID_ERROR;
1373 else if (!(state_flags & SF_GOT_STATUS))
1374 host_status = DID_ERROR;
1375 else if (!(state_flags & SF_GOT_SENSE))
1376 host_status = DID_ERROR;
1377 break;
1378
1379 case CS_RESET:
1380 host_status = DID_RESET;
1381 break;
1382
1383 case CS_ABORTED:
1384 host_status = DID_ABORT;
1385 break;
1386
1387 case CS_TIMEOUT:
1388 host_status = DID_TIME_OUT;
1389 break;
1390
1391 case CS_DATA_OVERRUN:
1392 dprintk(2, "Data overrun 0x%x\n", residual_length);
1393 dprintk(2, "qla1280_return_status: response packet data\n");
1394 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1395 host_status = DID_ERROR;
1396 break;
1397
1398 case CS_DATA_UNDERRUN:
1399 if ((scsi_bufflen(cp) - residual_length) <
1400 cp->underflow) {
1401 printk(KERN_WARNING
1402 "scsi: Underflow detected - retrying "
1403 "command.\n");
1404 host_status = DID_ERROR;
1405 } else {
1406 scsi_set_resid(cp, residual_length);
1407 host_status = DID_OK;
1408 }
1409 break;
1410
1411 default:
1412 host_status = DID_ERROR;
1413 break;
1414 }
1415
1416#if DEBUG_QLA1280_INTR
1417 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1418 reason[host_status], scsi_status);
1419#endif
1420
1421 LEAVE("qla1280_return_status");
1422
1423 return (scsi_status & 0xff) | (host_status << 16);
1424}
1425
1426/****************************************************************************/
1427/* QLogic ISP1280 Hardware Support Functions. */
1428/****************************************************************************/
1429
1430/*
1431 * qla1280_initialize_adapter
1432 * Initialize board.
1433 *
1434 * Input:
1435 * ha = adapter block pointer.
1436 *
1437 * Returns:
1438 * 0 = success
1439 */
1440static int __devinit
1441qla1280_initialize_adapter(struct scsi_qla_host *ha)
1442{
1443 struct device_reg __iomem *reg;
1444 int status;
1445 int bus;
1446 unsigned long flags;
1447
1448 ENTER("qla1280_initialize_adapter");
1449
1450 /* Clear adapter flags. */
1451 ha->flags.online = 0;
1452 ha->flags.disable_host_adapter = 0;
1453 ha->flags.reset_active = 0;
1454 ha->flags.abort_isp_active = 0;
1455
1456#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1457 if (ia64_platform_is("sn2")) {
1458 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
1459 "dual channel lockup workaround\n", ha->host_no);
1460 ha->flags.use_pci_vchannel = 1;
1461 driver_setup.no_nvram = 1;
1462 }
1463#endif
1464
1465 /* TODO: implement support for the 1040 nvram format */
1466 if (IS_ISP1040(ha))
1467 driver_setup.no_nvram = 1;
1468
1469 dprintk(1, "Configure PCI space for adapter...\n");
1470
1471 reg = ha->iobase;
1472
1473 /* Insure mailbox registers are free. */
1474 WRT_REG_WORD(®->semaphore, 0);
1475 WRT_REG_WORD(®->host_cmd, HC_CLR_RISC_INT);
1476 WRT_REG_WORD(®->host_cmd, HC_CLR_HOST_INT);
1477 RD_REG_WORD(®->host_cmd);
1478
1479 if (qla1280_read_nvram(ha)) {
1480 dprintk(2, "qla1280_initialize_adapter: failed to read "
1481 "NVRAM\n");
1482 }
1483
1484 /*
1485 * It's necessary to grab the spin here as qla1280_mailbox_command
1486 * needs to be able to drop the lock unconditionally to wait
1487 * for completion.
1488 */
1489 spin_lock_irqsave(ha->host->host_lock, flags);
1490
1491 status = qla1280_load_firmware(ha);
1492 if (status) {
1493 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1494 ha->host_no);
1495 goto out;
1496 }
1497
1498 /* Setup adapter based on NVRAM parameters. */
1499 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1500 qla1280_nvram_config(ha);
1501
1502 if (ha->flags.disable_host_adapter) {
1503 status = 1;
1504 goto out;
1505 }
1506
1507 status = qla1280_init_rings(ha);
1508 if (status)
1509 goto out;
1510
1511 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1512 for (bus = 0; bus < ha->ports; bus++) {
1513 if (!ha->bus_settings[bus].disable_scsi_reset &&
1514 qla1280_bus_reset(ha, bus) &&
1515 …Large files files are truncated, but you can click here to view the full file