blob: b8166ecfd0e35f17894a077679d5f5d2a29701cf [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/******************************************************************************
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******************************************************************************/
Michael Reed421e33d2010-03-23 15:00:58 -050020#define QLA1280_VERSION "3.27.1"
Linus Torvalds1da177e2005-04-16 15:20:36 -070021/*****************************************************************************
22 Revision History:
Michael Reed421e33d2010-03-23 15:00:58 -050023 Rev 3.27.1, February 8, 2010, Michael Reed
24 - Retain firmware image for error recovery.
Michael Reed413e6e12009-04-08 14:34:33 -050025 Rev 3.27, February 10, 2009, Michael Reed
26 - General code cleanup.
27 - Improve error recovery.
Jes Sorensen2dbb04c2006-01-16 11:49:29 -050028 Rev 3.26, January 16, 2006 Jes Sorensen
29 - Ditch all < 2.6 support
Linus Torvalds1da177e2005-04-16 15:20:36 -070030 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
Nick Andrewc3af1712009-01-03 18:57:37 +1100136 sent to the card - this command pauses the firmware!!!
Linus Torvalds1da177e2005-04-16 15:20:36 -0700137 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
Thomas Gleixner1d6f3592006-07-01 19:29:42 -0700200 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
Linus Torvalds1da177e2005-04-16 15:20:36 -0700201 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700339#include <linux/module.h>
340
Linus Torvalds1da177e2005-04-16 15:20:36 -0700341#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700348#include <linux/pci.h>
349#include <linux/proc_fs.h>
350#include <linux/stat.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700351#include <linux/pci_ids.h>
352#include <linux/interrupt.h>
353#include <linux/init.h>
Matthias Gehre910638a2006-03-28 01:56:48 -0800354#include <linux/dma-mapping.h>
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +0530355#include <linux/firmware.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700356
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700364#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>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700369
370#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
371#include <asm/sn/io.h>
372#endif
373
Linus Torvalds1da177e2005-04-16 15:20:36 -0700374
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700392#include "qla1280.h"
Linus Torvalds1da177e2005-04-16 15:20:36 -0700393
Linus Torvalds1da177e2005-04-16 15:20:36 -0700394#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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700410#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 *);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700429static 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700442static 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
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +0900526#define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
Linus Torvalds1da177e2005-04-16 15:20:36 -0700527#define CMD_RESULT(Cmnd) Cmnd->result
528#define CMD_HANDLE(Cmnd) Cmnd->host_scribble
Linus Torvalds1da177e2005-04-16 15:20:36 -0700529#define CMD_REQUEST(Cmnd) Cmnd->request->cmd
Linus Torvalds1da177e2005-04-16 15:20:36 -0700530
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 {
Michael Reed421e33d2010-03-23 15:00:58 -0500542 char *name; /* Board ID String */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700543 int numPorts; /* Number of SCSI ports */
Michael Reed421e33d2010-03-23 15:00:58 -0500544 int fw_index; /* index into qla1280_fw_tbl for firmware */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700545};
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},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700551 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
552 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700553 {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
Michael Reed421e33d2010-03-23 15:00:58 -0500565DEFINE_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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700581static struct qla_boards ql1280_board_tbl[] = {
Michael Reed421e33d2010-03-23 15:00:58 -0500582 {.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},
Linus Torvalds1da177e2005-04-16 15:20:36 -0700589};
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
Nick Andrewc3af1712009-01-03 18:57:37 +1100668 * little endian. However, the firmware interface requires it
Linus Torvalds1da177e2005-04-16 15:20:36 -0700669 * 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",
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +0530713 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700714 QLA1280_VERSION);
715 return bp;
716}
717
718/**************************************************************************
Michael Reedfd65e5e2009-04-08 14:33:48 -0500719 * qla1280_queuecommand
Linus Torvalds1da177e2005-04-16 15:20:36 -0700720 * 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;
Michael Reedfd65e5e2009-04-08 14:33:48 -0500734 struct srb *sp = (struct srb *)CMD_SP(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700735 int status;
736
737 cmd->scsi_done = fn;
738 sp->cmd = cmd;
739 sp->flags = 0;
Michael Reed413e6e12009-04-08 14:34:33 -0500740 sp->wait = NULL;
741 CMD_HANDLE(cmd) = (unsigned char *)NULL;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700742
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,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700761 DEVICE_RESET,
762 BUS_RESET,
763 ADAPTER_RESET,
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764};
765
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
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(&reg->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(&reg->ictrl), RD_REG_WORD(&reg->istatus));
777 complete(ha->mailbox_wait);
778}
779
Michael Reed413e6e12009-04-08 14:34:33 -0500780static 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700839/**************************************************************************
Michael Reedfd65e5e2009-04-08 14:33:48 -0500840 * qla1280_error_action
Linus Torvalds1da177e2005-04-16 15:20:36 -0700841 * 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 *
Linus Torvalds1da177e2005-04-16 15:20:36 -0700852 **************************************************************************/
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;
Michael Reed413e6e12009-04-08 14:34:33 -0500859 int i, found;
860 int result=FAILED;
861 int wait_for_bus=-1;
862 int wait_for_target = -1;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -0700863 DECLARE_COMPLETION_ONSTACK(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700864
Michael Reedfd65e5e2009-04-08 14:33:48 -0500865 ENTER("qla1280_error_action");
866
Linus Torvalds1da177e2005-04-16 15:20:36 -0700867 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
Michael Reed413e6e12009-04-08 14:34:33 -0500868 sp = (struct srb *)CMD_SP(cmd);
869 bus = SCSI_BUS_32(cmd);
870 target = SCSI_TCN_32(cmd);
871 lun = SCSI_LUN_32(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700872
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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700880 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
Linus Torvalds1da177e2005-04-16 15:20:36 -0700885 /*
Michael Reed413e6e12009-04-08 14:34:33 -0500886 * 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.
Linus Torvalds1da177e2005-04-16 15:20:36 -0700890 */
Michael Reed413e6e12009-04-08 14:34:33 -0500891 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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700896 break;
897 }
Michael Reed413e6e12009-04-08 14:34:33 -0500898 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700899
Michael Reed413e6e12009-04-08 14:34:33 -0500900 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700907 }
Michael Reed413e6e12009-04-08 14:34:33 -0500908 }
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700921 break;
922
Linus Torvalds1da177e2005-04-16 15:20:36 -0700923 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);
Michael Reed413e6e12009-04-08 14:34:33 -0500928 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700933 break;
934
935 case BUS_RESET:
936 if (qla1280_verbose)
Jes Sorensencd00b7f2006-10-17 09:32:06 -0400937 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
938 "reset.\n", ha->host_no, bus);
Michael Reed413e6e12009-04-08 14:34:33 -0500939 if (qla1280_bus_reset(ha, bus) == 0) {
940 /* issued bus reset, set wait conditions */
941 wait_for_bus = bus;
942 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700943 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;
Michael Reed413e6e12009-04-08 14:34:33 -0500955
956 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
957 result = FAILED;
958 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700959
960 ha->flags.reset_active = 0;
961 }
962
Michael Reed413e6e12009-04-08 14:34:33 -0500963 /*
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 */
Linus Torvalds1da177e2005-04-16 15:20:36 -0700971
Michael Reed413e6e12009-04-08 14:34:33 -0500972 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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700980 }
981
Michael Reed413e6e12009-04-08 14:34:33 -0500982 /*
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);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700995 }
996
Linus Torvalds1da177e2005-04-16 15:20:36 -0700997 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{
Jeff Garzik 8fa728a2005-05-28 07:54:40 -04001010 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001017}
1018
1019/**************************************************************************
1020 * qla1280_device_reset
1021 * Reset the specified SCSI device
1022 **************************************************************************/
1023static int
1024qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1025{
Jeff Garzik 94d0e7b82005-05-28 07:55:48 -04001026 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033}
1034
1035/**************************************************************************
1036 * qla1280_bus_reset
1037 * Reset the specified bus.
1038 **************************************************************************/
1039static int
1040qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1041{
Jeff Garzik 68b3aa72005-05-28 07:56:31 -04001042 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001049}
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{
Jeff Garzik df0ae242005-05-28 07:57:14 -04001058 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001065}
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
Christoph Hellwig 8af50dc2005-07-04 17:48:19 +02001091
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}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001107
1108/**************************************************************************
1109 * qla1280_intr_handler
1110 * Handles the H/W interrupt
1111 **************************************************************************/
1112static irqreturn_t
David Howells7d12e782006-10-05 14:55:46 +01001113qla1280_intr_handler(int irq, void *dev_id)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001114{
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
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001123 spin_lock(ha->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001124
1125 ha->isr_count++;
1126 reg = ha->iobase;
1127
Christoph Hellwig 8af50dc2005-07-04 17:48:19 +02001128 qla1280_disable_intrs(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001129
1130 data = qla1280_debounce_register(&reg->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
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001139 spin_unlock(ha->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001140
Christoph Hellwig 8af50dc2005-07-04 17:48:19 +02001141 qla1280_enable_intrs(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001142
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;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001154 int status, lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001155
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;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001162 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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001171
1172 if (IS_ISP1x160(ha)) {
1173 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001174 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001175 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 {
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001179 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001180 }
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001181 mb[3] |= nv->bus[bus].target[target].sync_period;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001182
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001183 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 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001194
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
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001239 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1240 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001241 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242
1243 if (driver_setup.no_sync ||
1244 (driver_setup.sync_mask &&
1245 (~driver_setup.sync_mask & (1 << target))))
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001246 nv->bus[bus].target[target].parameter.enable_sync = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 if (driver_setup.no_wide ||
1248 (driver_setup.wide_mask &&
1249 (~driver_setup.wide_mask & (1 << target))))
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001250 nv->bus[bus].target[target].parameter.enable_wide = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001251 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
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001258 spin_lock_irqsave(ha->host->host_lock, flags);
Christoph Hellwig 7a347662005-07-04 17:49:22 +02001259 if (nv->bus[bus].target[target].parameter.enable_sync)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001260 status = qla1280_set_target_parameters(ha, bus, target);
1261 qla1280_get_target_parameters(ha, device);
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001262 spin_unlock_irqrestore(ha->host->host_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001263 return status;
1264}
1265
Linus Torvalds1da177e2005-04-16 15:20:36 -07001266
1267/*
1268 * qla1280_done
1269 * Process completed commands.
1270 *
1271 * Input:
1272 * ha = adapter block pointer.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001273 */
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. */
Michael Reed413e6e12009-04-08 14:34:33 -05001299 if (!ha->flags.abort_isp_active)
1300 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001301 break;
1302 case DID_ABORT:
1303 sp->flags &= ~SRB_ABORT_PENDING;
1304 sp->flags |= SRB_ABORTED;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001305 break;
1306 default:
1307 break;
1308 }
1309
1310 /* Release memory used for this I/O */
Jes Sorensen5c1da582007-11-09 14:40:41 +01001311 scsi_dma_unmap(cmd);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001312
1313 /* Call the mid-level driver interrupt handler */
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 ha->actthreads--;
1315
Michael Reed413e6e12009-04-08 14:34:33 -05001316 if (sp->wait == NULL)
1317 (*(cmd)->scsi_done)(cmd);
1318 else
Linus Torvalds1da177e2005-04-16 15:20:36 -07001319 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);
Jes Sorensen3ef49a32007-01-05 12:05:37 -05001333 uint32_t residual_length = le32_to_cpu(sts->residual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001334 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);
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02001393 dprintk(2, "qla1280_return_status: response packet data\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07001394 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1395 host_status = DID_ERROR;
1396 break;
1397
1398 case CS_DATA_UNDERRUN:
Jes Sorensen5c1da582007-11-09 14:40:41 +01001399 if ((scsi_bufflen(cp) - residual_length) <
Linus Torvalds1da177e2005-04-16 15:20:36 -07001400 cp->underflow) {
1401 printk(KERN_WARNING
1402 "scsi: Underflow detected - retrying "
1403 "command.\n");
1404 host_status = DID_ERROR;
Jes Sorensen3ef49a32007-01-05 12:05:37 -05001405 } else {
Jes Sorensen5c1da582007-11-09 14:40:41 +01001406 scsi_set_resid(cp, residual_length);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001407 host_status = DID_OK;
Jes Sorensen3ef49a32007-01-05 12:05:37 -05001408 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07001409 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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001430/*
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;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001446 unsigned long flags;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001447
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
Linus Torvalds1da177e2005-04-16 15:20:36 -07001456#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(&reg->semaphore, 0);
1475 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
1476 WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
1477 RD_REG_WORD(&reg->host_cmd);
1478
1479 if (qla1280_read_nvram(ha)) {
1480 dprintk(2, "qla1280_initialize_adapter: failed to read "
1481 "NVRAM\n");
1482 }
1483
Linus Torvalds1da177e2005-04-16 15:20:36 -07001484 /*
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.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001488 */
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001489 spin_lock_irqsave(ha->host->host_lock, flags);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001490
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 qla1280_bus_reset(ha, bus))
1516 ha->bus_settings[bus].scsi_bus_dead = 1;
1517 }
1518
1519 ha->flags.online = 1;
1520 out:
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05001521 spin_unlock_irqrestore(ha->host->host_lock, flags);
1522
Linus Torvalds1da177e2005-04-16 15:20:36 -07001523 if (status)
1524 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1525
1526 LEAVE("qla1280_initialize_adapter");
1527 return status;
1528}
1529
Linus Torvalds1da177e2005-04-16 15:20:36 -07001530/*
Michael Reed421e33d2010-03-23 15:00:58 -05001531 * qla1280_request_firmware
1532 * Acquire firmware for chip. Retain in memory
1533 * for error recovery.
1534 *
1535 * Input:
1536 * ha = adapter block pointer.
1537 *
1538 * Returns:
1539 * Pointer to firmware image or an error code
1540 * cast to pointer via ERR_PTR().
1541 */
1542static const struct firmware *
1543qla1280_request_firmware(struct scsi_qla_host *ha)
1544{
1545 const struct firmware *fw;
1546 int err;
1547 int index;
1548 char *fwname;
1549
1550 spin_unlock_irq(ha->host->host_lock);
1551 mutex_lock(&qla1280_firmware_mutex);
1552
1553 index = ql1280_board_tbl[ha->devnum].fw_index;
1554 fw = qla1280_fw_tbl[index].fw;
1555 if (fw)
1556 goto out;
1557
1558 fwname = qla1280_fw_tbl[index].fwname;
1559 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1560
1561 if (err) {
1562 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1563 fwname, err);
1564 fw = ERR_PTR(err);
1565 goto unlock;
1566 }
1567 if ((fw->size % 2) || (fw->size < 6)) {
1568 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1569 fw->size, fwname);
1570 release_firmware(fw);
1571 fw = ERR_PTR(-EINVAL);
1572 goto unlock;
1573 }
1574
1575 qla1280_fw_tbl[index].fw = fw;
1576
1577 out:
1578 ha->fwver1 = fw->data[0];
1579 ha->fwver2 = fw->data[1];
1580 ha->fwver3 = fw->data[2];
1581 unlock:
1582 mutex_unlock(&qla1280_firmware_mutex);
1583 spin_lock_irq(ha->host->host_lock);
1584 return fw;
1585}
1586
1587/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001588 * Chip diagnostics
1589 * Test chip for proper operation.
1590 *
1591 * Input:
1592 * ha = adapter block pointer.
1593 *
1594 * Returns:
1595 * 0 = success.
1596 */
1597static int
1598qla1280_chip_diag(struct scsi_qla_host *ha)
1599{
1600 uint16_t mb[MAILBOX_REGISTER_COUNT];
1601 struct device_reg __iomem *reg = ha->iobase;
1602 int status = 0;
1603 int cnt;
1604 uint16_t data;
1605 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", &reg->id_l);
1606
1607 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1608
1609 /* Soft reset chip and wait for it to finish. */
1610 WRT_REG_WORD(&reg->ictrl, ISP_RESET);
1611
1612 /*
1613 * We can't do a traditional PCI write flush here by reading
1614 * back the register. The card will not respond once the reset
1615 * is in action and we end up with a machine check exception
1616 * instead. Nothing to do but wait and hope for the best.
1617 * A portable pci_write_flush(pdev) call would be very useful here.
1618 */
1619 udelay(20);
1620 data = qla1280_debounce_register(&reg->ictrl);
1621 /*
1622 * Yet another QLogic gem ;-(
1623 */
1624 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1625 udelay(5);
1626 data = RD_REG_WORD(&reg->ictrl);
1627 }
1628
1629 if (!cnt)
1630 goto fail;
1631
1632 /* Reset register cleared by chip reset. */
1633 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1634
1635 WRT_REG_WORD(&reg->cfg_1, 0);
1636
1637 /* Reset RISC and disable BIOS which
1638 allows RISC to execute out of RAM. */
1639 WRT_REG_WORD(&reg->host_cmd, HC_RESET_RISC |
1640 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1641
1642 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
1643 data = qla1280_debounce_register(&reg->mailbox0);
1644
1645 /*
1646 * I *LOVE* this code!
1647 */
1648 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1649 udelay(5);
1650 data = RD_REG_WORD(&reg->mailbox0);
1651 }
1652
1653 if (!cnt)
1654 goto fail;
1655
1656 /* Check product ID of chip */
1657 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1658
1659 if (RD_REG_WORD(&reg->mailbox1) != PROD_ID_1 ||
1660 (RD_REG_WORD(&reg->mailbox2) != PROD_ID_2 &&
1661 RD_REG_WORD(&reg->mailbox2) != PROD_ID_2a) ||
1662 RD_REG_WORD(&reg->mailbox3) != PROD_ID_3 ||
1663 RD_REG_WORD(&reg->mailbox4) != PROD_ID_4) {
1664 printk(KERN_INFO "qla1280: Wrong product ID = "
1665 "0x%x,0x%x,0x%x,0x%x\n",
1666 RD_REG_WORD(&reg->mailbox1),
1667 RD_REG_WORD(&reg->mailbox2),
1668 RD_REG_WORD(&reg->mailbox3),
1669 RD_REG_WORD(&reg->mailbox4));
1670 goto fail;
1671 }
1672
1673 /*
1674 * Enable ints early!!!
1675 */
1676 qla1280_enable_intrs(ha);
1677
1678 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1679 /* Wrap Incoming Mailboxes Test. */
1680 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1681 mb[1] = 0xAAAA;
1682 mb[2] = 0x5555;
1683 mb[3] = 0xAA55;
1684 mb[4] = 0x55AA;
1685 mb[5] = 0xA5A5;
1686 mb[6] = 0x5A5A;
1687 mb[7] = 0x2525;
1688
1689 status = qla1280_mailbox_command(ha, 0xff, mb);
1690 if (status)
1691 goto fail;
1692
1693 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1694 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1695 mb[7] != 0x2525) {
1696 printk(KERN_INFO "qla1280: Failed mbox check\n");
1697 goto fail;
1698 }
1699
1700 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1701 return 0;
1702 fail:
1703 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1704 return status;
1705}
1706
1707static int
1708qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1709{
Michael Reed421e33d2010-03-23 15:00:58 -05001710 /* enter with host_lock acquired */
1711
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301712 const struct firmware *fw;
1713 const __le16 *fw_data;
1714 uint16_t risc_address, risc_code_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001715 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
Michael Reed421e33d2010-03-23 15:00:58 -05001716 int err = 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717
Michael Reed421e33d2010-03-23 15:00:58 -05001718 fw = qla1280_request_firmware(ha);
1719 if (IS_ERR(fw))
1720 return PTR_ERR(fw);
1721
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301722 fw_data = (const __le16 *)&fw->data[0];
1723 ha->fwstart = __le16_to_cpu(fw_data[2]);
1724
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725 /* Load RISC code. */
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301726 risc_address = ha->fwstart;
David Woodhouse0ce49d62009-04-08 01:22:36 -07001727 fw_data = (const __le16 *)&fw->data[6];
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301728 risc_code_size = (fw->size - 6) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001729
1730 for (i = 0; i < risc_code_size; i++) {
1731 mb[0] = MBC_WRITE_RAM_WORD;
1732 mb[1] = risc_address + i;
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301733 mb[2] = __le16_to_cpu(fw_data[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001734
1735 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1736 if (err) {
1737 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1738 ha->host_no);
Michael Reed421e33d2010-03-23 15:00:58 -05001739 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001740 }
1741 }
Michael Reed421e33d2010-03-23 15:00:58 -05001742
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301743 return err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001744}
1745
1746#define DUMP_IT_BACK 0 /* for debug of RISC loading */
1747static int
1748qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1749{
Michael Reed421e33d2010-03-23 15:00:58 -05001750 /* enter with host_lock acquired */
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301751 const struct firmware *fw;
1752 const __le16 *fw_data;
1753 uint16_t risc_address, risc_code_size;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001754 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1755 int err = 0, num, i;
1756#if DUMP_IT_BACK
1757 uint8_t *sp, *tbuf;
1758 dma_addr_t p_tbuf;
1759
1760 tbuf = pci_alloc_consistent(ha->pdev, 8000, &p_tbuf);
1761 if (!tbuf)
1762 return -ENOMEM;
1763#endif
1764
Michael Reed421e33d2010-03-23 15:00:58 -05001765 fw = qla1280_request_firmware(ha);
1766 if (IS_ERR(fw))
1767 return PTR_ERR(fw);
1768
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301769 fw_data = (const __le16 *)&fw->data[0];
1770 ha->fwstart = __le16_to_cpu(fw_data[2]);
1771
Linus Torvalds1da177e2005-04-16 15:20:36 -07001772 /* Load RISC code. */
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301773 risc_address = ha->fwstart;
David Woodhouse0ce49d62009-04-08 01:22:36 -07001774 fw_data = (const __le16 *)&fw->data[6];
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301775 risc_code_size = (fw->size - 6) / 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
1777 dprintk(1, "%s: DMA RISC code (%i) words\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001778 __func__, risc_code_size);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001779
1780 num = 0;
1781 while (risc_code_size > 0) {
1782 int warn __attribute__((unused)) = 0;
1783
1784 cnt = 2000 >> 1;
1785
1786 if (cnt > risc_code_size)
1787 cnt = risc_code_size;
1788
1789 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1790 "%d,%d(0x%x)\n",
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301791 fw_data, cnt, num, risc_address);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001792 for(i = 0; i < cnt; i++)
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301793 ((__le16 *)ha->request_ring)[i] = fw_data[i];
Linus Torvalds1da177e2005-04-16 15:20:36 -07001794
1795 mb[0] = MBC_LOAD_RAM;
1796 mb[1] = risc_address;
1797 mb[4] = cnt;
1798 mb[3] = ha->request_dma & 0xffff;
1799 mb[2] = (ha->request_dma >> 16) & 0xffff;
1800 mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
1801 mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
1802 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001803 __func__, mb[0],
Linus Torvalds1da177e2005-04-16 15:20:36 -07001804 (void *)(long)ha->request_dma,
1805 mb[6], mb[7], mb[2], mb[3]);
1806 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1807 BIT_1 | BIT_0, mb);
1808 if (err) {
1809 printk(KERN_ERR "scsi(%li): Failed to load partial "
1810 "segment of f\n", ha->host_no);
1811 goto out;
1812 }
1813
1814#if DUMP_IT_BACK
1815 mb[0] = MBC_DUMP_RAM;
1816 mb[1] = risc_address;
1817 mb[4] = cnt;
1818 mb[3] = p_tbuf & 0xffff;
1819 mb[2] = (p_tbuf >> 16) & 0xffff;
1820 mb[7] = pci_dma_hi32(p_tbuf) & 0xffff;
1821 mb[6] = pci_dma_hi32(p_tbuf) >> 16;
1822
1823 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1824 BIT_1 | BIT_0, mb);
1825 if (err) {
1826 printk(KERN_ERR
1827 "Failed to dump partial segment of f/w\n");
1828 goto out;
1829 }
1830 sp = (uint8_t *)ha->request_ring;
1831 for (i = 0; i < (cnt << 1); i++) {
1832 if (tbuf[i] != sp[i] && warn++ < 10) {
1833 printk(KERN_ERR "%s: FW compare error @ "
1834 "byte(0x%x) loop#=%x\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001835 __func__, i, num);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001836 printk(KERN_ERR "%s: FWbyte=%x "
1837 "FWfromChip=%x\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001838 __func__, sp[i], tbuf[i]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 /*break; */
1840 }
1841 }
1842#endif
1843 risc_address += cnt;
1844 risc_code_size = risc_code_size - cnt;
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301845 fw_data = fw_data + cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001846 num++;
1847 }
1848
1849 out:
1850#if DUMP_IT_BACK
1851 pci_free_consistent(ha->pdev, 8000, tbuf, p_tbuf);
1852#endif
1853 return err;
1854}
1855
1856static int
1857qla1280_start_firmware(struct scsi_qla_host *ha)
1858{
1859 uint16_t mb[MAILBOX_REGISTER_COUNT];
1860 int err;
1861
1862 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001863 __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001864
1865 /* Verify checksum of loaded RISC code. */
1866 mb[0] = MBC_VERIFY_CHECKSUM;
1867 /* mb[1] = ql12_risc_code_addr01; */
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301868 mb[1] = ha->fwstart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001869 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1870 if (err) {
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02001871 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001872 return err;
1873 }
1874
1875 /* Start firmware execution. */
Harvey Harrisoncadbd4a2008-07-03 23:47:27 -07001876 dprintk(1, "%s: start firmware running.\n", __func__);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001877 mb[0] = MBC_EXECUTE_FIRMWARE;
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05301878 mb[1] = ha->fwstart;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001879 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1880 if (err) {
1881 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1882 ha->host_no);
1883 }
1884
1885 return err;
1886}
1887
1888static int
1889qla1280_load_firmware(struct scsi_qla_host *ha)
1890{
Michael Reed421e33d2010-03-23 15:00:58 -05001891 /* enter with host_lock taken */
Christoph Hellwig 5c79d612005-07-04 17:48:46 +02001892 int err;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001893
1894 err = qla1280_chip_diag(ha);
1895 if (err)
1896 goto out;
1897 if (IS_ISP1040(ha))
1898 err = qla1280_load_firmware_pio(ha);
1899 else
1900 err = qla1280_load_firmware_dma(ha);
1901 if (err)
1902 goto out;
1903 err = qla1280_start_firmware(ha);
1904 out:
1905 return err;
1906}
1907
1908/*
1909 * Initialize rings
1910 *
1911 * Input:
1912 * ha = adapter block pointer.
1913 * ha->request_ring = request ring virtual address
1914 * ha->response_ring = response ring virtual address
1915 * ha->request_dma = request ring physical address
1916 * ha->response_dma = response ring physical address
1917 *
1918 * Returns:
1919 * 0 = success.
1920 */
1921static int
1922qla1280_init_rings(struct scsi_qla_host *ha)
1923{
1924 uint16_t mb[MAILBOX_REGISTER_COUNT];
1925 int status = 0;
1926
1927 ENTER("qla1280_init_rings");
1928
1929 /* Clear outstanding commands array. */
1930 memset(ha->outstanding_cmds, 0,
1931 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1932
1933 /* Initialize request queue. */
1934 ha->request_ring_ptr = ha->request_ring;
1935 ha->req_ring_index = 0;
1936 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1937 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1938 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1939 mb[1] = REQUEST_ENTRY_CNT;
1940 mb[3] = ha->request_dma & 0xffff;
1941 mb[2] = (ha->request_dma >> 16) & 0xffff;
1942 mb[4] = 0;
1943 mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
1944 mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
1945 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1946 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1947 &mb[0]))) {
1948 /* Initialize response queue. */
1949 ha->response_ring_ptr = ha->response_ring;
1950 ha->rsp_ring_index = 0;
1951 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1952 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1953 mb[1] = RESPONSE_ENTRY_CNT;
1954 mb[3] = ha->response_dma & 0xffff;
1955 mb[2] = (ha->response_dma >> 16) & 0xffff;
1956 mb[5] = 0;
1957 mb[7] = pci_dma_hi32(ha->response_dma) & 0xffff;
1958 mb[6] = pci_dma_hi32(ha->response_dma) >> 16;
1959 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1960 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1961 &mb[0]);
1962 }
1963
1964 if (status)
1965 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1966
1967 LEAVE("qla1280_init_rings");
1968 return status;
1969}
1970
1971static void
1972qla1280_print_settings(struct nvram *nv)
1973{
1974 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1975 nv->bus[0].config_1.initiator_id);
1976 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1977 nv->bus[1].config_1.initiator_id);
1978
1979 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1980 nv->bus[0].bus_reset_delay);
1981 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1982 nv->bus[1].bus_reset_delay);
1983
1984 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1985 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1986 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1987 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1988
1989 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1990 nv->bus[0].config_2.async_data_setup_time);
1991 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1992 nv->bus[1].config_2.async_data_setup_time);
1993
1994 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1995 nv->bus[0].config_2.req_ack_active_negation);
1996 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1997 nv->bus[1].config_2.req_ack_active_negation);
1998
1999 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
2000 nv->bus[0].config_2.data_line_active_negation);
2001 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
2002 nv->bus[1].config_2.data_line_active_negation);
2003
2004 dprintk(1, "qla1280 : disable loading risc code=%d\n",
2005 nv->cntr_flags_1.disable_loading_risc_code);
2006
2007 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
2008 nv->cntr_flags_1.enable_64bit_addressing);
2009
2010 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
2011 nv->bus[0].selection_timeout);
2012 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
2013 nv->bus[1].selection_timeout);
2014
2015 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
2016 nv->bus[0].max_queue_depth);
2017 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
2018 nv->bus[1].max_queue_depth);
2019}
2020
2021static void
2022qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
2023{
2024 struct nvram *nv = &ha->nvram;
2025
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002026 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
2027 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
2028 nv->bus[bus].target[target].parameter.tag_queuing = 1;
2029 nv->bus[bus].target[target].parameter.enable_sync = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002030#if 1 /* Some SCSI Processors do not seem to like this */
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002031 nv->bus[bus].target[target].parameter.enable_wide = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002032#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07002033 nv->bus[bus].target[target].execution_throttle =
2034 nv->bus[bus].max_queue_depth - 1;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002035 nv->bus[bus].target[target].parameter.parity_checking = 1;
2036 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002037
2038 if (IS_ISP1x160(ha)) {
2039 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2040 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2041 nv->bus[bus].target[target].sync_period = 9;
2042 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2043 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2044 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2045 } else {
2046 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2047 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2048 nv->bus[bus].target[target].sync_period = 10;
2049 }
2050}
2051
2052static void
2053qla1280_set_defaults(struct scsi_qla_host *ha)
2054{
2055 struct nvram *nv = &ha->nvram;
2056 int bus, target;
2057
2058 dprintk(1, "Using defaults for NVRAM: \n");
2059 memset(nv, 0, sizeof(struct nvram));
2060
2061 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2062 nv->firmware_feature.f.enable_fast_posting = 1;
2063 nv->firmware_feature.f.disable_synchronous_backoff = 1;
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002064 nv->termination.scsi_bus_0_control = 3;
2065 nv->termination.scsi_bus_1_control = 3;
2066 nv->termination.auto_term_support = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002067
2068 /*
2069 * Set default FIFO magic - What appropriate values would be here
2070 * is unknown. This is what I have found testing with 12160s.
2071 *
2072 * Now, I would love the magic decoder ring for this one, the
2073 * header file provided by QLogic seems to be bogus or incomplete
2074 * at best.
2075 */
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002076 nv->isp_config.burst_enable = 1;
2077 if (IS_ISP1040(ha))
2078 nv->isp_config.fifo_threshold |= 3;
2079 else
2080 nv->isp_config.fifo_threshold |= 4;
2081
Linus Torvalds1da177e2005-04-16 15:20:36 -07002082 if (IS_ISP1x160(ha))
2083 nv->isp_parameter = 0x01; /* fast memory enable */
2084
2085 for (bus = 0; bus < MAX_BUSES; bus++) {
2086 nv->bus[bus].config_1.initiator_id = 7;
2087 nv->bus[bus].config_2.req_ack_active_negation = 1;
2088 nv->bus[bus].config_2.data_line_active_negation = 1;
2089 nv->bus[bus].selection_timeout = 250;
Jeremy Higdonaf5741c2008-05-11 23:17:03 -07002090 nv->bus[bus].max_queue_depth = 32;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002091
2092 if (IS_ISP1040(ha)) {
2093 nv->bus[bus].bus_reset_delay = 3;
2094 nv->bus[bus].config_2.async_data_setup_time = 6;
2095 nv->bus[bus].retry_delay = 1;
2096 } else {
2097 nv->bus[bus].bus_reset_delay = 5;
2098 nv->bus[bus].config_2.async_data_setup_time = 8;
2099 }
2100
2101 for (target = 0; target < MAX_TARGETS; target++)
2102 qla1280_set_target_defaults(ha, bus, target);
2103 }
2104}
2105
2106static int
2107qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2108{
2109 struct nvram *nv = &ha->nvram;
2110 uint16_t mb[MAILBOX_REGISTER_COUNT];
2111 int status, lun;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002112 uint16_t flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002113
2114 /* Set Target Parameters. */
2115 mb[0] = MBC_SET_TARGET_PARAMETERS;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002116 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002117
2118 /*
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002119 * Do not enable sync and ppr for the initial INQUIRY run. We
2120 * enable this later if we determine the target actually
2121 * supports it.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 */
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002123 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2124 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002125
2126 if (IS_ISP1x160(ha))
2127 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2128 else
2129 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2130 mb[3] |= nv->bus[bus].target[target].sync_period;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002131 status = qla1280_mailbox_command(ha, 0x0f, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002132
2133 /* Save Tag queuing enable flag. */
Jeremy Higdonaf5741c2008-05-11 23:17:03 -07002134 flag = (BIT_0 << target);
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002135 if (nv->bus[bus].target[target].parameter.tag_queuing)
2136 ha->bus_settings[bus].qtag_enables |= flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002137
2138 /* Save Device enable flag. */
2139 if (IS_ISP1x160(ha)) {
2140 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002141 ha->bus_settings[bus].device_enables |= flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002142 ha->bus_settings[bus].lun_disables |= 0;
2143 } else {
2144 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002145 ha->bus_settings[bus].device_enables |= flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002146 /* Save LUN disable flag. */
2147 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002148 ha->bus_settings[bus].lun_disables |= flag;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002149 }
2150
2151 /* Set Device Queue Parameters. */
2152 for (lun = 0; lun < MAX_LUNS; lun++) {
2153 mb[0] = MBC_SET_DEVICE_QUEUE;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002154 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2155 mb[1] |= lun;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002156 mb[2] = nv->bus[bus].max_queue_depth;
2157 mb[3] = nv->bus[bus].target[target].execution_throttle;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002158 status |= qla1280_mailbox_command(ha, 0x0f, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002159 }
2160
2161 return status;
2162}
2163
2164static int
2165qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2166{
2167 struct nvram *nv = &ha->nvram;
2168 uint16_t mb[MAILBOX_REGISTER_COUNT];
2169 int target, status;
2170
2171 /* SCSI Reset Disable. */
2172 ha->bus_settings[bus].disable_scsi_reset =
2173 nv->bus[bus].config_1.scsi_reset_disable;
2174
2175 /* Initiator ID. */
2176 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2177 mb[0] = MBC_SET_INITIATOR_ID;
2178 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2179 ha->bus_settings[bus].id;
2180 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2181
2182 /* Reset Delay. */
2183 ha->bus_settings[bus].bus_reset_delay =
2184 nv->bus[bus].bus_reset_delay;
2185
2186 /* Command queue depth per device. */
2187 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2188
2189 /* Set target parameters. */
2190 for (target = 0; target < MAX_TARGETS; target++)
2191 status |= qla1280_config_target(ha, bus, target);
2192
2193 return status;
2194}
2195
2196static int
2197qla1280_nvram_config(struct scsi_qla_host *ha)
2198{
2199 struct device_reg __iomem *reg = ha->iobase;
2200 struct nvram *nv = &ha->nvram;
2201 int bus, target, status = 0;
2202 uint16_t mb[MAILBOX_REGISTER_COUNT];
Linus Torvalds1da177e2005-04-16 15:20:36 -07002203
2204 ENTER("qla1280_nvram_config");
2205
2206 if (ha->nvram_valid) {
2207 /* Always force AUTO sense for LINUX SCSI */
2208 for (bus = 0; bus < MAX_BUSES; bus++)
2209 for (target = 0; target < MAX_TARGETS; target++) {
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002210 nv->bus[bus].target[target].parameter.
Linus Torvalds1da177e2005-04-16 15:20:36 -07002211 auto_request_sense = 1;
2212 }
2213 } else {
2214 qla1280_set_defaults(ha);
2215 }
2216
2217 qla1280_print_settings(nv);
2218
2219 /* Disable RISC load of firmware. */
2220 ha->flags.disable_risc_code_load =
2221 nv->cntr_flags_1.disable_loading_risc_code;
2222
2223 if (IS_ISP1040(ha)) {
2224 uint16_t hwrev, cfg1, cdma_conf, ddma_conf;
2225
2226 hwrev = RD_REG_WORD(&reg->cfg_0) & ISP_CFG0_HWMSK;
2227
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002228 cfg1 = RD_REG_WORD(&reg->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002229 cdma_conf = RD_REG_WORD(&reg->cdma_cfg);
2230 ddma_conf = RD_REG_WORD(&reg->ddma_cfg);
2231
2232 /* Busted fifo, says mjacob. */
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002233 if (hwrev != ISP_CFG0_1040A)
2234 cfg1 |= nv->isp_config.fifo_threshold << 4;
2235
2236 cfg1 |= nv->isp_config.burst_enable << 2;
2237 WRT_REG_WORD(&reg->cfg_1, cfg1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238
2239 WRT_REG_WORD(&reg->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2240 WRT_REG_WORD(&reg->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2241 } else {
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002242 uint16_t cfg1, term;
2243
Linus Torvalds1da177e2005-04-16 15:20:36 -07002244 /* Set ISP hardware DMA burst */
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002245 cfg1 = nv->isp_config.fifo_threshold << 4;
2246 cfg1 |= nv->isp_config.burst_enable << 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002247 /* Enable DMA arbitration on dual channel controllers */
2248 if (ha->ports > 1)
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002249 cfg1 |= BIT_13;
2250 WRT_REG_WORD(&reg->cfg_1, cfg1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002251
2252 /* Set SCSI termination. */
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002253 WRT_REG_WORD(&reg->gpio_enable,
2254 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2255 term = nv->termination.scsi_bus_1_control;
2256 term |= nv->termination.scsi_bus_0_control << 2;
2257 term |= nv->termination.auto_term_support << 7;
2258 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2259 WRT_REG_WORD(&reg->gpio_data, term);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002260 }
Christoph Hellwig 0888f4c2005-07-04 17:48:55 +02002261 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002262
2263 /* ISP parameter word. */
2264 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2265 mb[1] = nv->isp_parameter;
2266 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2267
2268 if (IS_ISP1x40(ha)) {
2269 /* clock rate - for qla1240 and older, only */
2270 mb[0] = MBC_SET_CLOCK_RATE;
2271 mb[1] = 40;
2272 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2273 }
2274
2275 /* Firmware feature word. */
2276 mb[0] = MBC_SET_FIRMWARE_FEATURES;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002277 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2278 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2279 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002280#if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2281 if (ia64_platform_is("sn2")) {
2282 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
2283 "workaround\n", ha->host_no);
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002284 mb[1] |= nv->firmware_feature.f.unused_9 << 9; /* XXX */
Linus Torvalds1da177e2005-04-16 15:20:36 -07002285 }
2286#endif
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002287 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002288
2289 /* Retry count and delay. */
2290 mb[0] = MBC_SET_RETRY_COUNT;
2291 mb[1] = nv->bus[0].retry_count;
2292 mb[2] = nv->bus[0].retry_delay;
2293 mb[6] = nv->bus[1].retry_count;
2294 mb[7] = nv->bus[1].retry_delay;
2295 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2296 BIT_1 | BIT_0, &mb[0]);
2297
2298 /* ASYNC data setup time. */
2299 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2300 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2301 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2302 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2303
2304 /* Active negation states. */
2305 mb[0] = MBC_SET_ACTIVE_NEGATION;
2306 mb[1] = 0;
2307 if (nv->bus[0].config_2.req_ack_active_negation)
2308 mb[1] |= BIT_5;
2309 if (nv->bus[0].config_2.data_line_active_negation)
2310 mb[1] |= BIT_4;
2311 mb[2] = 0;
2312 if (nv->bus[1].config_2.req_ack_active_negation)
2313 mb[2] |= BIT_5;
2314 if (nv->bus[1].config_2.data_line_active_negation)
2315 mb[2] |= BIT_4;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002316 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317
2318 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2319 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002320 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002321
2322 /* thingy */
2323 mb[0] = MBC_SET_PCI_CONTROL;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002324 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2325 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2326 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002327
2328 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2329 mb[1] = 8;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002330 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002331
2332 /* Selection timeout. */
2333 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2334 mb[1] = nv->bus[0].selection_timeout;
2335 mb[2] = nv->bus[1].selection_timeout;
Christoph Hellwig 7a347662005-07-04 17:49:22 +02002336 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002337
2338 for (bus = 0; bus < ha->ports; bus++)
2339 status |= qla1280_config_bus(ha, bus);
2340
2341 if (status)
2342 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2343
2344 LEAVE("qla1280_nvram_config");
2345 return status;
2346}
2347
2348/*
2349 * Get NVRAM data word
2350 * Calculates word position in NVRAM and calls request routine to
2351 * get the word from NVRAM.
2352 *
2353 * Input:
2354 * ha = adapter block pointer.
2355 * address = NVRAM word address.
2356 *
2357 * Returns:
2358 * data word.
2359 */
2360static uint16_t
2361qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2362{
2363 uint32_t nv_cmd;
2364 uint16_t data;
2365
2366 nv_cmd = address << 16;
2367 nv_cmd |= NV_READ_OP;
2368
2369 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2370
2371 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2372 "0x%x", data);
2373
2374 return data;
2375}
2376
2377/*
2378 * NVRAM request
2379 * Sends read command to NVRAM and gets data from NVRAM.
2380 *
2381 * Input:
2382 * ha = adapter block pointer.
2383 * nv_cmd = Bit 26 = start bit
2384 * Bit 25, 24 = opcode
2385 * Bit 23-16 = address
2386 * Bit 15-0 = write data
2387 *
2388 * Returns:
2389 * data word.
2390 */
2391static uint16_t
2392qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2393{
2394 struct device_reg __iomem *reg = ha->iobase;
2395 int cnt;
2396 uint16_t data = 0;
2397 uint16_t reg_data;
2398
2399 /* Send command to NVRAM. */
2400
2401 nv_cmd <<= 5;
2402 for (cnt = 0; cnt < 11; cnt++) {
2403 if (nv_cmd & BIT_31)
2404 qla1280_nv_write(ha, NV_DATA_OUT);
2405 else
2406 qla1280_nv_write(ha, 0);
2407 nv_cmd <<= 1;
2408 }
2409
2410 /* Read data from NVRAM. */
2411
2412 for (cnt = 0; cnt < 16; cnt++) {
2413 WRT_REG_WORD(&reg->nvram, (NV_SELECT | NV_CLOCK));
2414 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2415 NVRAM_DELAY();
2416 data <<= 1;
2417 reg_data = RD_REG_WORD(&reg->nvram);
2418 if (reg_data & NV_DATA_IN)
2419 data |= BIT_0;
2420 WRT_REG_WORD(&reg->nvram, NV_SELECT);
2421 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2422 NVRAM_DELAY();
2423 }
2424
2425 /* Deselect chip. */
2426
2427 WRT_REG_WORD(&reg->nvram, NV_DESELECT);
2428 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2429 NVRAM_DELAY();
2430
2431 return data;
2432}
2433
2434static void
2435qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2436{
2437 struct device_reg __iomem *reg = ha->iobase;
2438
2439 WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2440 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2441 NVRAM_DELAY();
2442 WRT_REG_WORD(&reg->nvram, data | NV_SELECT | NV_CLOCK);
2443 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2444 NVRAM_DELAY();
2445 WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2446 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2447 NVRAM_DELAY();
2448}
2449
2450/*
2451 * Mailbox Command
2452 * Issue mailbox command and waits for completion.
2453 *
2454 * Input:
2455 * ha = adapter block pointer.
2456 * mr = mailbox registers to load.
2457 * mb = data pointer for mailbox registers.
2458 *
2459 * Output:
2460 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2461 *
2462 * Returns:
2463 * 0 = success
2464 */
2465static int
2466qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2467{
2468 struct device_reg __iomem *reg = ha->iobase;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002469 int status = 0;
2470 int cnt;
2471 uint16_t *optr, *iptr;
2472 uint16_t __iomem *mptr;
2473 uint16_t data;
Peter Zijlstra6e9a4732006-09-30 23:28:10 -07002474 DECLARE_COMPLETION_ONSTACK(wait);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002475 struct timer_list timer;
2476
2477 ENTER("qla1280_mailbox_command");
2478
2479 if (ha->mailbox_wait) {
2480 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2481 }
2482 ha->mailbox_wait = &wait;
2483
2484 /*
2485 * We really should start out by verifying that the mailbox is
2486 * available before starting sending the command data
2487 */
2488 /* Load mailbox registers. */
2489 mptr = (uint16_t __iomem *) &reg->mailbox0;
2490 iptr = mb;
2491 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2492 if (mr & BIT_0) {
2493 WRT_REG_WORD(mptr, (*iptr));
2494 }
2495
2496 mr >>= 1;
2497 mptr++;
2498 iptr++;
2499 }
2500
2501 /* Issue set host interrupt command. */
2502
2503 /* set up a timer just in case we're really jammed */
2504 init_timer(&timer);
2505 timer.expires = jiffies + 20*HZ;
2506 timer.data = (unsigned long)ha;
2507 timer.function = qla1280_mailbox_timeout;
2508 add_timer(&timer);
2509
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05002510 spin_unlock_irq(ha->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002511 WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
2512 data = qla1280_debounce_register(&reg->istatus);
2513
2514 wait_for_completion(&wait);
2515 del_timer_sync(&timer);
2516
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05002517 spin_lock_irq(ha->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002518
2519 ha->mailbox_wait = NULL;
2520
2521 /* Check for mailbox command timeout. */
2522 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2523 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2524 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2525 "0x%04x\n",
2526 mb[0], ha->mailbox_out[0], RD_REG_WORD(&reg->istatus));
2527 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2528 RD_REG_WORD(&reg->mailbox0), RD_REG_WORD(&reg->mailbox1),
2529 RD_REG_WORD(&reg->mailbox2), RD_REG_WORD(&reg->mailbox3));
2530 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2531 RD_REG_WORD(&reg->mailbox4), RD_REG_WORD(&reg->mailbox5),
2532 RD_REG_WORD(&reg->mailbox6), RD_REG_WORD(&reg->mailbox7));
2533 status = 1;
2534 }
2535
2536 /* Load return mailbox registers. */
2537 optr = mb;
2538 iptr = (uint16_t *) &ha->mailbox_out[0];
2539 mr = MAILBOX_REGISTER_COUNT;
2540 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2541
Linus Torvalds1da177e2005-04-16 15:20:36 -07002542 if (ha->flags.reset_marker)
2543 qla1280_rst_aen(ha);
2544
Linus Torvalds1da177e2005-04-16 15:20:36 -07002545 if (status)
2546 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2547 "0x%x ****\n", mb[0]);
2548
2549 LEAVE("qla1280_mailbox_command");
2550 return status;
2551}
2552
2553/*
2554 * qla1280_poll
2555 * Polls ISP for interrupts.
2556 *
2557 * Input:
2558 * ha = adapter block pointer.
2559 */
2560static void
2561qla1280_poll(struct scsi_qla_host *ha)
2562{
2563 struct device_reg __iomem *reg = ha->iobase;
2564 uint16_t data;
2565 LIST_HEAD(done_q);
2566
2567 /* ENTER("qla1280_poll"); */
2568
2569 /* Check for pending interrupts. */
2570 data = RD_REG_WORD(&reg->istatus);
2571 if (data & RISC_INT)
2572 qla1280_isr(ha, &done_q);
2573
2574 if (!ha->mailbox_wait) {
2575 if (ha->flags.reset_marker)
2576 qla1280_rst_aen(ha);
2577 }
2578
2579 if (!list_empty(&done_q))
2580 qla1280_done(ha);
2581
2582 /* LEAVE("qla1280_poll"); */
2583}
2584
2585/*
2586 * qla1280_bus_reset
2587 * Issue SCSI bus reset.
2588 *
2589 * Input:
2590 * ha = adapter block pointer.
2591 * bus = SCSI bus number.
2592 *
2593 * Returns:
2594 * 0 = success
2595 */
2596static int
2597qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2598{
2599 uint16_t mb[MAILBOX_REGISTER_COUNT];
2600 uint16_t reset_delay;
2601 int status;
2602
2603 dprintk(3, "qla1280_bus_reset: entered\n");
2604
2605 if (qla1280_verbose)
2606 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2607 ha->host_no, bus);
2608
2609 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2610 mb[0] = MBC_BUS_RESET;
2611 mb[1] = reset_delay;
2612 mb[2] = (uint16_t) bus;
2613 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2614
2615 if (status) {
2616 if (ha->bus_settings[bus].failed_reset_count > 2)
2617 ha->bus_settings[bus].scsi_bus_dead = 1;
2618 ha->bus_settings[bus].failed_reset_count++;
2619 } else {
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05002620 spin_unlock_irq(ha->host->host_lock);
Nishanth Aravamudan117e4b22005-06-20 23:55:07 +02002621 ssleep(reset_delay);
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05002622 spin_lock_irq(ha->host->host_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002623
2624 ha->bus_settings[bus].scsi_bus_dead = 0;
2625 ha->bus_settings[bus].failed_reset_count = 0;
2626 ha->bus_settings[bus].reset_marker = 0;
2627 /* Issue marker command. */
2628 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2629 }
2630
2631 /*
2632 * We should probably call qla1280_set_target_parameters()
2633 * here as well for all devices on the bus.
2634 */
2635
2636 if (status)
2637 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2638 else
2639 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2640
2641 return status;
2642}
2643
2644/*
2645 * qla1280_device_reset
2646 * Issue bus device reset message to the target.
2647 *
2648 * Input:
2649 * ha = adapter block pointer.
2650 * bus = SCSI BUS number.
2651 * target = SCSI ID.
2652 *
2653 * Returns:
2654 * 0 = success
2655 */
2656static int
2657qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2658{
2659 uint16_t mb[MAILBOX_REGISTER_COUNT];
2660 int status;
2661
2662 ENTER("qla1280_device_reset");
2663
2664 mb[0] = MBC_ABORT_TARGET;
2665 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2666 mb[2] = 1;
2667 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2668
2669 /* Issue marker command. */
2670 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2671
2672 if (status)
2673 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2674
2675 LEAVE("qla1280_device_reset");
2676 return status;
2677}
2678
2679/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07002680 * qla1280_abort_command
2681 * Abort command aborts a specified IOCB.
2682 *
2683 * Input:
2684 * ha = adapter block pointer.
2685 * sp = SB structure pointer.
2686 *
2687 * Returns:
2688 * 0 = success
2689 */
2690static int
2691qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2692{
2693 uint16_t mb[MAILBOX_REGISTER_COUNT];
2694 unsigned int bus, target, lun;
2695 int status;
2696
2697 ENTER("qla1280_abort_command");
2698
2699 bus = SCSI_BUS_32(sp->cmd);
2700 target = SCSI_TCN_32(sp->cmd);
2701 lun = SCSI_LUN_32(sp->cmd);
2702
2703 sp->flags |= SRB_ABORT_PENDING;
2704
2705 mb[0] = MBC_ABORT_COMMAND;
2706 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2707 mb[2] = handle >> 16;
2708 mb[3] = handle & 0xffff;
2709 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2710
2711 if (status) {
2712 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2713 sp->flags &= ~SRB_ABORT_PENDING;
2714 }
2715
2716
2717 LEAVE("qla1280_abort_command");
2718 return status;
2719}
2720
2721/*
2722 * qla1280_reset_adapter
2723 * Reset adapter.
2724 *
2725 * Input:
2726 * ha = adapter block pointer.
2727 */
2728static void
2729qla1280_reset_adapter(struct scsi_qla_host *ha)
2730{
2731 struct device_reg __iomem *reg = ha->iobase;
2732
2733 ENTER("qla1280_reset_adapter");
2734
2735 /* Disable ISP chip */
2736 ha->flags.online = 0;
2737 WRT_REG_WORD(&reg->ictrl, ISP_RESET);
2738 WRT_REG_WORD(&reg->host_cmd,
2739 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2740 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2741
2742 LEAVE("qla1280_reset_adapter");
2743}
2744
2745/*
2746 * Issue marker command.
2747 * Function issues marker IOCB.
2748 *
2749 * Input:
2750 * ha = adapter block pointer.
2751 * bus = SCSI BUS number
2752 * id = SCSI ID
2753 * lun = SCSI LUN
2754 * type = marker modifier
2755 */
2756static void
2757qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2758{
2759 struct mrk_entry *pkt;
2760
2761 ENTER("qla1280_marker");
2762
2763 /* Get request packet. */
2764 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2765 pkt->entry_type = MARKER_TYPE;
2766 pkt->lun = (uint8_t) lun;
2767 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2768 pkt->modifier = type;
2769 pkt->entry_status = 0;
2770
2771 /* Issue command to ISP */
2772 qla1280_isp_cmd(ha);
2773 }
2774
2775 LEAVE("qla1280_marker");
2776}
2777
2778
2779/*
2780 * qla1280_64bit_start_scsi
2781 * The start SCSI is responsible for building request packets on
2782 * request ring and modifying ISP input pointer.
2783 *
2784 * Input:
2785 * ha = adapter block pointer.
2786 * sp = SB structure pointer.
2787 *
2788 * Returns:
2789 * 0 = success, was able to issue command.
2790 */
2791#ifdef QLA_64BIT_PTR
2792static int
2793qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2794{
2795 struct device_reg __iomem *reg = ha->iobase;
2796 struct scsi_cmnd *cmd = sp->cmd;
2797 cmd_a64_entry_t *pkt;
Christoph Hellwig 8d6810d2005-07-04 17:49:26 +02002798 __le32 *dword_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002799 dma_addr_t dma_handle;
2800 int status = 0;
2801 int cnt;
2802 int req_cnt;
Jes Sorensen5c1da582007-11-09 14:40:41 +01002803 int seg_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002804 u8 dir;
2805
2806 ENTER("qla1280_64bit_start_scsi:");
2807
2808 /* Calculate number of entries and segments required. */
2809 req_cnt = 1;
Jes Sorensen5c1da582007-11-09 14:40:41 +01002810 seg_cnt = scsi_dma_map(cmd);
2811 if (seg_cnt > 0) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002812 if (seg_cnt > 2) {
2813 req_cnt += (seg_cnt - 2) / 5;
2814 if ((seg_cnt - 2) % 5)
2815 req_cnt++;
2816 }
Jes Sorensen5c1da582007-11-09 14:40:41 +01002817 } else if (seg_cnt < 0) {
2818 status = 1;
2819 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002820 }
2821
2822 if ((req_cnt + 2) >= ha->req_q_cnt) {
2823 /* Calculate number of free request entries. */
2824 cnt = RD_REG_WORD(&reg->mailbox4);
2825 if (ha->req_ring_index < cnt)
2826 ha->req_q_cnt = cnt - ha->req_ring_index;
2827 else
2828 ha->req_q_cnt =
2829 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2830 }
2831
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02002832 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2833 ha->req_q_cnt, seg_cnt);
2834
Linus Torvalds1da177e2005-04-16 15:20:36 -07002835 /* If room for request in request ring. */
2836 if ((req_cnt + 2) >= ha->req_q_cnt) {
Michael Reedfd65e5e2009-04-08 14:33:48 -05002837 status = SCSI_MLQUEUE_HOST_BUSY;
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02002838 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
Linus Torvalds1da177e2005-04-16 15:20:36 -07002839 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2840 req_cnt);
2841 goto out;
2842 }
2843
2844 /* Check for room in outstanding command list. */
2845 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
Harvey Harrison9bcf0912008-05-22 15:45:07 -07002846 ha->outstanding_cmds[cnt] != NULL; cnt++);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002847
2848 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
Michael Reedfd65e5e2009-04-08 14:33:48 -05002849 status = SCSI_MLQUEUE_HOST_BUSY;
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02002850 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
Linus Torvalds1da177e2005-04-16 15:20:36 -07002851 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2852 goto out;
2853 }
2854
2855 ha->outstanding_cmds[cnt] = sp;
2856 ha->req_q_cnt -= req_cnt;
2857 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2858
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02002859 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002860 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2861 dprintk(2, " bus %i, target %i, lun %i\n",
2862 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2863 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2864
2865 /*
2866 * Build command packet.
2867 */
2868 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2869
2870 pkt->entry_type = COMMAND_A64_TYPE;
2871 pkt->entry_count = (uint8_t) req_cnt;
2872 pkt->sys_define = (uint8_t) ha->req_ring_index;
2873 pkt->entry_status = 0;
2874 pkt->handle = cpu_to_le32(cnt);
2875
2876 /* Zero out remaining portion of packet. */
2877 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2878
2879 /* Set ISP command timeout. */
Jens Axboe242f9dc2008-09-14 05:55:09 -07002880 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002881
2882 /* Set device target ID and LUN */
2883 pkt->lun = SCSI_LUN_32(cmd);
2884 pkt->target = SCSI_BUS_32(cmd) ?
2885 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2886
2887 /* Enable simple tag queuing if device supports it. */
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05002888 if (cmd->device->simple_tags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002889 pkt->control_flags |= cpu_to_le16(BIT_3);
2890
2891 /* Load SCSI command packet. */
2892 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
Boaz Harrosh64a87b22008-04-30 11:19:47 +03002893 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002894 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2895
2896 /* Set transfer direction. */
2897 dir = qla1280_data_direction(cmd);
2898 pkt->control_flags |= cpu_to_le16(dir);
2899
2900 /* Set total data segment count. */
2901 pkt->dseg_count = cpu_to_le16(seg_cnt);
2902
2903 /*
2904 * Load data segments.
2905 */
2906 if (seg_cnt) { /* If data transfer. */
Jes Sorensen5c1da582007-11-09 14:40:41 +01002907 struct scatterlist *sg, *s;
Jens Axboea0441892007-05-09 13:02:43 +02002908 int remseg = seg_cnt;
Jes Sorensen5c1da582007-11-09 14:40:41 +01002909
2910 sg = scsi_sglist(cmd);
2911
Linus Torvalds1da177e2005-04-16 15:20:36 -07002912 /* Setup packet address segment pointer. */
2913 dword_ptr = (u32 *)&pkt->dseg_0_address;
2914
Jes Sorensen5c1da582007-11-09 14:40:41 +01002915 /* Load command entry data segments. */
2916 for_each_sg(sg, s, seg_cnt, cnt) {
2917 if (cnt == 2)
2918 break;
2919
2920 dma_handle = sg_dma_address(s);
2921#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2922 if (ha->flags.use_pci_vchannel)
2923 sn_pci_set_vchan(ha->pdev,
2924 (unsigned long *)&dma_handle,
2925 SCSI_BUS_32(cmd));
2926#endif
2927 *dword_ptr++ =
2928 cpu_to_le32(pci_dma_lo32(dma_handle));
2929 *dword_ptr++ =
2930 cpu_to_le32(pci_dma_hi32(dma_handle));
2931 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2932 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2933 cpu_to_le32(pci_dma_hi32(dma_handle)),
2934 cpu_to_le32(pci_dma_lo32(dma_handle)),
2935 cpu_to_le32(sg_dma_len(sg_next(s))));
2936 remseg--;
2937 }
2938 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2939 "command packet data - b %i, t %i, l %i \n",
2940 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2941 SCSI_LUN_32(cmd));
2942 qla1280_dump_buffer(5, (char *)pkt,
2943 REQUEST_ENTRY_SIZE);
2944
2945 /*
2946 * Build continuation packets.
2947 */
2948 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2949 "remains\n", seg_cnt);
2950
2951 while (remseg > 0) {
2952 /* Update sg start */
2953 sg = s;
2954 /* Adjust ring index. */
2955 ha->req_ring_index++;
2956 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2957 ha->req_ring_index = 0;
2958 ha->request_ring_ptr =
2959 ha->request_ring;
2960 } else
2961 ha->request_ring_ptr++;
2962
2963 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2964
2965 /* Zero out packet. */
2966 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2967
2968 /* Load packet defaults. */
2969 ((struct cont_a64_entry *) pkt)->entry_type =
2970 CONTINUE_A64_TYPE;
2971 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2972 ((struct cont_a64_entry *) pkt)->sys_define =
2973 (uint8_t)ha->req_ring_index;
2974 /* Setup packet address segment pointer. */
2975 dword_ptr =
2976 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2977
2978 /* Load continuation entry data segments. */
2979 for_each_sg(sg, s, remseg, cnt) {
2980 if (cnt == 5)
Jens Axboea0441892007-05-09 13:02:43 +02002981 break;
2982 dma_handle = sg_dma_address(s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002983#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2984 if (ha->flags.use_pci_vchannel)
2985 sn_pci_set_vchan(ha->pdev,
Jes Sorensen5c1da582007-11-09 14:40:41 +01002986 (unsigned long *)&dma_handle,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002987 SCSI_BUS_32(cmd));
2988#endif
2989 *dword_ptr++ =
2990 cpu_to_le32(pci_dma_lo32(dma_handle));
2991 *dword_ptr++ =
2992 cpu_to_le32(pci_dma_hi32(dma_handle));
Jes Sorensen5c1da582007-11-09 14:40:41 +01002993 *dword_ptr++ =
2994 cpu_to_le32(sg_dma_len(s));
2995 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
Linus Torvalds1da177e2005-04-16 15:20:36 -07002996 cpu_to_le32(pci_dma_hi32(dma_handle)),
2997 cpu_to_le32(pci_dma_lo32(dma_handle)),
Jes Sorensen5c1da582007-11-09 14:40:41 +01002998 cpu_to_le32(sg_dma_len(s)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002999 }
Jes Sorensen5c1da582007-11-09 14:40:41 +01003000 remseg -= cnt;
3001 dprintk(5, "qla1280_64bit_start_scsi: "
3002 "continuation packet data - b %i, t "
3003 "%i, l %i \n", SCSI_BUS_32(cmd),
3004 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003005 qla1280_dump_buffer(5, (char *)pkt,
3006 REQUEST_ENTRY_SIZE);
3007 }
3008 } else { /* No data transfer */
3009 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
3010 "packet data - b %i, t %i, l %i \n",
3011 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3012 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3013 }
3014 /* Adjust ring index. */
3015 ha->req_ring_index++;
3016 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3017 ha->req_ring_index = 0;
3018 ha->request_ring_ptr = ha->request_ring;
3019 } else
3020 ha->request_ring_ptr++;
3021
3022 /* Set chip new ring index. */
3023 dprintk(2,
3024 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3025 sp->flags |= SRB_SENT;
3026 ha->actthreads++;
3027 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
3028 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3029 mmiowb();
3030
3031 out:
3032 if (status)
3033 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3034 else
3035 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3036
3037 return status;
3038}
3039#else /* !QLA_64BIT_PTR */
3040
3041/*
3042 * qla1280_32bit_start_scsi
3043 * The start SCSI is responsible for building request packets on
3044 * request ring and modifying ISP input pointer.
3045 *
3046 * The Qlogic firmware interface allows every queue slot to have a SCSI
3047 * command and up to 4 scatter/gather (SG) entries. If we need more
3048 * than 4 SG entries, then continuation entries are used that can
3049 * hold another 7 entries each. The start routine determines if there
3050 * is eought empty slots then build the combination of requests to
3051 * fulfill the OS request.
3052 *
3053 * Input:
3054 * ha = adapter block pointer.
3055 * sp = SCSI Request Block structure pointer.
3056 *
3057 * Returns:
3058 * 0 = success, was able to issue command.
3059 */
3060static int
3061qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
3062{
3063 struct device_reg __iomem *reg = ha->iobase;
3064 struct scsi_cmnd *cmd = sp->cmd;
3065 struct cmd_entry *pkt;
Christoph Hellwig 8d6810d2005-07-04 17:49:26 +02003066 __le32 *dword_ptr;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003067 int status = 0;
3068 int cnt;
3069 int req_cnt;
Jes Sorensen5c1da582007-11-09 14:40:41 +01003070 int seg_cnt;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003071 u8 dir;
3072
3073 ENTER("qla1280_32bit_start_scsi");
3074
3075 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3076 cmd->cmnd[0]);
3077
3078 /* Calculate number of entries and segments required. */
FUJITA Tomonori3a43e692008-01-08 23:07:01 +09003079 req_cnt = 1;
Jes Sorensen5c1da582007-11-09 14:40:41 +01003080 seg_cnt = scsi_dma_map(cmd);
3081 if (seg_cnt) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003082 /*
3083 * if greater than four sg entries then we need to allocate
3084 * continuation entries
3085 */
3086 if (seg_cnt > 4) {
3087 req_cnt += (seg_cnt - 4) / 7;
3088 if ((seg_cnt - 4) % 7)
3089 req_cnt++;
3090 }
3091 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3092 cmd, seg_cnt, req_cnt);
Jes Sorensen5c1da582007-11-09 14:40:41 +01003093 } else if (seg_cnt < 0) {
3094 status = 1;
3095 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003096 }
3097
3098 if ((req_cnt + 2) >= ha->req_q_cnt) {
3099 /* Calculate number of free request entries. */
3100 cnt = RD_REG_WORD(&reg->mailbox4);
3101 if (ha->req_ring_index < cnt)
3102 ha->req_q_cnt = cnt - ha->req_ring_index;
3103 else
3104 ha->req_q_cnt =
3105 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3106 }
3107
3108 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3109 ha->req_q_cnt, seg_cnt);
3110 /* If room for request in request ring. */
3111 if ((req_cnt + 2) >= ha->req_q_cnt) {
Michael Reedfd65e5e2009-04-08 14:33:48 -05003112 status = SCSI_MLQUEUE_HOST_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003113 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3114 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3115 ha->req_q_cnt, req_cnt);
3116 goto out;
3117 }
3118
3119 /* Check for empty slot in outstanding command list. */
3120 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3121 (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3122
3123 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
Michael Reedfd65e5e2009-04-08 14:33:48 -05003124 status = SCSI_MLQUEUE_HOST_BUSY;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003125 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3126 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3127 goto out;
3128 }
3129
3130 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3131 ha->outstanding_cmds[cnt] = sp;
3132 ha->req_q_cnt -= req_cnt;
3133
3134 /*
3135 * Build command packet.
3136 */
3137 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3138
3139 pkt->entry_type = COMMAND_TYPE;
3140 pkt->entry_count = (uint8_t) req_cnt;
3141 pkt->sys_define = (uint8_t) ha->req_ring_index;
3142 pkt->entry_status = 0;
3143 pkt->handle = cpu_to_le32(cnt);
3144
3145 /* Zero out remaining portion of packet. */
3146 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3147
3148 /* Set ISP command timeout. */
Jens Axboe242f9dc2008-09-14 05:55:09 -07003149 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003150
3151 /* Set device target ID and LUN */
3152 pkt->lun = SCSI_LUN_32(cmd);
3153 pkt->target = SCSI_BUS_32(cmd) ?
3154 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3155
3156 /* Enable simple tag queuing if device supports it. */
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05003157 if (cmd->device->simple_tags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07003158 pkt->control_flags |= cpu_to_le16(BIT_3);
3159
3160 /* Load SCSI command packet. */
3161 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
Boaz Harrosh64a87b22008-04-30 11:19:47 +03003162 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003163
3164 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3165 /* Set transfer direction. */
3166 dir = qla1280_data_direction(cmd);
3167 pkt->control_flags |= cpu_to_le16(dir);
3168
3169 /* Set total data segment count. */
3170 pkt->dseg_count = cpu_to_le16(seg_cnt);
3171
3172 /*
3173 * Load data segments.
3174 */
3175 if (seg_cnt) {
Jes Sorensen5c1da582007-11-09 14:40:41 +01003176 struct scatterlist *sg, *s;
Jens Axboea0441892007-05-09 13:02:43 +02003177 int remseg = seg_cnt;
Jes Sorensen5c1da582007-11-09 14:40:41 +01003178
3179 sg = scsi_sglist(cmd);
3180
Linus Torvalds1da177e2005-04-16 15:20:36 -07003181 /* Setup packet address segment pointer. */
3182 dword_ptr = &pkt->dseg_0_address;
3183
Jes Sorensen5c1da582007-11-09 14:40:41 +01003184 dprintk(3, "Building S/G data segments..\n");
3185 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003186
Jes Sorensen5c1da582007-11-09 14:40:41 +01003187 /* Load command entry data segments. */
3188 for_each_sg(sg, s, seg_cnt, cnt) {
3189 if (cnt == 4)
3190 break;
3191 *dword_ptr++ =
3192 cpu_to_le32(pci_dma_lo32(sg_dma_address(s)));
3193 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3194 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3195 (pci_dma_lo32(sg_dma_address(s))),
3196 (sg_dma_len(s)));
3197 remseg--;
3198 }
3199 /*
3200 * Build continuation packets.
3201 */
3202 dprintk(3, "S/G Building Continuation"
3203 "...seg_cnt=0x%x remains\n", seg_cnt);
3204 while (remseg > 0) {
3205 /* Continue from end point */
3206 sg = s;
3207 /* Adjust ring index. */
3208 ha->req_ring_index++;
3209 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3210 ha->req_ring_index = 0;
3211 ha->request_ring_ptr =
3212 ha->request_ring;
3213 } else
3214 ha->request_ring_ptr++;
3215
3216 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3217
3218 /* Zero out packet. */
3219 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3220
3221 /* Load packet defaults. */
3222 ((struct cont_entry *) pkt)->
3223 entry_type = CONTINUE_TYPE;
3224 ((struct cont_entry *) pkt)->entry_count = 1;
3225
3226 ((struct cont_entry *) pkt)->sys_define =
3227 (uint8_t) ha->req_ring_index;
3228
3229 /* Setup packet address segment pointer. */
3230 dword_ptr =
3231 &((struct cont_entry *) pkt)->dseg_0_address;
3232
3233 /* Load continuation entry data segments. */
3234 for_each_sg(sg, s, remseg, cnt) {
3235 if (cnt == 7)
Jens Axboea0441892007-05-09 13:02:43 +02003236 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003237 *dword_ptr++ =
Jens Axboea0441892007-05-09 13:02:43 +02003238 cpu_to_le32(pci_dma_lo32(sg_dma_address(s)));
Jes Sorensen5c1da582007-11-09 14:40:41 +01003239 *dword_ptr++ =
3240 cpu_to_le32(sg_dma_len(s));
3241 dprintk(1,
3242 "S/G Segment Cont. phys_addr=0x%x, "
3243 "len=0x%x\n",
3244 cpu_to_le32(pci_dma_lo32(sg_dma_address(s))),
3245 cpu_to_le32(sg_dma_len(s)));
Linus Torvalds1da177e2005-04-16 15:20:36 -07003246 }
Jes Sorensen5c1da582007-11-09 14:40:41 +01003247 remseg -= cnt;
3248 dprintk(5, "qla1280_32bit_start_scsi: "
3249 "continuation packet data - "
3250 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3251 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3252 qla1280_dump_buffer(5, (char *)pkt,
3253 REQUEST_ENTRY_SIZE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003254 }
3255 } else { /* No data transfer at all */
3256 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3257 "packet data - \n");
3258 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3259 }
3260 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3261 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3262 REQUEST_ENTRY_SIZE);
3263
3264 /* Adjust ring index. */
3265 ha->req_ring_index++;
3266 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3267 ha->req_ring_index = 0;
3268 ha->request_ring_ptr = ha->request_ring;
3269 } else
3270 ha->request_ring_ptr++;
3271
3272 /* Set chip new ring index. */
3273 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3274 "for pending command\n");
3275 sp->flags |= SRB_SENT;
3276 ha->actthreads++;
3277 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
3278 /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3279 mmiowb();
3280
3281out:
3282 if (status)
3283 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3284
3285 LEAVE("qla1280_32bit_start_scsi");
3286
3287 return status;
3288}
3289#endif
3290
3291/*
3292 * qla1280_req_pkt
3293 * Function is responsible for locking ring and
3294 * getting a zeroed out request packet.
3295 *
3296 * Input:
3297 * ha = adapter block pointer.
3298 *
3299 * Returns:
3300 * 0 = failed to get slot.
3301 */
3302static request_t *
3303qla1280_req_pkt(struct scsi_qla_host *ha)
3304{
3305 struct device_reg __iomem *reg = ha->iobase;
3306 request_t *pkt = NULL;
3307 int cnt;
3308 uint32_t timer;
3309
3310 ENTER("qla1280_req_pkt");
3311
3312 /*
3313 * This can be called from interrupt context, damn it!!!
3314 */
3315 /* Wait for 30 seconds for slot. */
3316 for (timer = 15000000; timer; timer--) {
3317 if (ha->req_q_cnt > 0) {
3318 /* Calculate number of free request entries. */
3319 cnt = RD_REG_WORD(&reg->mailbox4);
3320 if (ha->req_ring_index < cnt)
3321 ha->req_q_cnt = cnt - ha->req_ring_index;
3322 else
3323 ha->req_q_cnt =
3324 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3325 }
3326
3327 /* Found empty request ring slot? */
3328 if (ha->req_q_cnt > 0) {
3329 ha->req_q_cnt--;
3330 pkt = ha->request_ring_ptr;
3331
3332 /* Zero out packet. */
3333 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3334
3335 /*
3336 * How can this be right when we have a ring
3337 * size of 512???
3338 */
3339 /* Set system defined field. */
3340 pkt->sys_define = (uint8_t) ha->req_ring_index;
3341
3342 /* Set entry count. */
3343 pkt->entry_count = 1;
3344
3345 break;
3346 }
3347
3348 udelay(2); /* 10 */
3349
3350 /* Check for pending interrupts. */
3351 qla1280_poll(ha);
3352 }
3353
3354 if (!pkt)
3355 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3356 else
3357 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3358
3359 return pkt;
3360}
3361
3362/*
3363 * qla1280_isp_cmd
3364 * Function is responsible for modifying ISP input pointer.
3365 * Releases ring lock.
3366 *
3367 * Input:
3368 * ha = adapter block pointer.
3369 */
3370static void
3371qla1280_isp_cmd(struct scsi_qla_host *ha)
3372{
3373 struct device_reg __iomem *reg = ha->iobase;
3374
3375 ENTER("qla1280_isp_cmd");
3376
3377 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3378 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3379 REQUEST_ENTRY_SIZE);
3380
3381 /* Adjust ring index. */
3382 ha->req_ring_index++;
3383 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3384 ha->req_ring_index = 0;
3385 ha->request_ring_ptr = ha->request_ring;
3386 } else
3387 ha->request_ring_ptr++;
3388
3389 /*
3390 * Update request index to mailbox4 (Request Queue In).
3391 * The mmiowb() ensures that this write is ordered with writes by other
3392 * CPUs. Without the mmiowb(), it is possible for the following:
3393 * CPUA posts write of index 5 to mailbox4
3394 * CPUA releases host lock
3395 * CPUB acquires host lock
3396 * CPUB posts write of index 6 to mailbox4
3397 * On PCI bus, order reverses and write of 6 posts, then index 5,
3398 * causing chip to issue full queue of stale commands
3399 * The mmiowb() prevents future writes from crossing the barrier.
3400 * See Documentation/DocBook/deviceiobook.tmpl for more information.
3401 */
3402 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
3403 mmiowb();
3404
3405 LEAVE("qla1280_isp_cmd");
3406}
3407
3408/****************************************************************************/
3409/* Interrupt Service Routine. */
3410/****************************************************************************/
3411
3412/****************************************************************************
3413 * qla1280_isr
3414 * Calls I/O done on command completion.
3415 *
3416 * Input:
3417 * ha = adapter block pointer.
3418 * done_q = done queue.
3419 ****************************************************************************/
3420static void
3421qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3422{
3423 struct device_reg __iomem *reg = ha->iobase;
3424 struct response *pkt;
3425 struct srb *sp = NULL;
3426 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3427 uint16_t *wptr;
3428 uint32_t index;
3429 u16 istatus;
3430
3431 ENTER("qla1280_isr");
3432
3433 istatus = RD_REG_WORD(&reg->istatus);
3434 if (!(istatus & (RISC_INT | PCI_INT)))
3435 return;
3436
3437 /* Save mailbox register 5 */
3438 mailbox[5] = RD_REG_WORD(&reg->mailbox5);
3439
3440 /* Check for mailbox interrupt. */
3441
3442 mailbox[0] = RD_REG_WORD_dmasync(&reg->semaphore);
3443
3444 if (mailbox[0] & BIT_0) {
3445 /* Get mailbox data. */
3446 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3447
3448 wptr = &mailbox[0];
3449 *wptr++ = RD_REG_WORD(&reg->mailbox0);
3450 *wptr++ = RD_REG_WORD(&reg->mailbox1);
3451 *wptr = RD_REG_WORD(&reg->mailbox2);
3452 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3453 wptr++;
3454 *wptr++ = RD_REG_WORD(&reg->mailbox3);
3455 *wptr++ = RD_REG_WORD(&reg->mailbox4);
3456 wptr++;
3457 *wptr++ = RD_REG_WORD(&reg->mailbox6);
3458 *wptr = RD_REG_WORD(&reg->mailbox7);
3459 }
3460
3461 /* Release mailbox registers. */
3462
3463 WRT_REG_WORD(&reg->semaphore, 0);
3464 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
3465
3466 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3467 mailbox[0]);
3468
3469 /* Handle asynchronous event */
3470 switch (mailbox[0]) {
3471 case MBA_SCSI_COMPLETION: /* Response completion */
3472 dprintk(5, "qla1280_isr: mailbox SCSI response "
3473 "completion\n");
3474
3475 if (ha->flags.online) {
3476 /* Get outstanding command index. */
3477 index = mailbox[2] << 16 | mailbox[1];
3478
3479 /* Validate handle. */
3480 if (index < MAX_OUTSTANDING_COMMANDS)
3481 sp = ha->outstanding_cmds[index];
3482 else
3483 sp = NULL;
3484
3485 if (sp) {
3486 /* Free outstanding command slot. */
3487 ha->outstanding_cmds[index] = NULL;
3488
3489 /* Save ISP completion status */
3490 CMD_RESULT(sp->cmd) = 0;
Michael Reed413e6e12009-04-08 14:34:33 -05003491 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003492
3493 /* Place block on done queue */
3494 list_add_tail(&sp->list, done_q);
3495 } else {
3496 /*
3497 * If we get here we have a real problem!
3498 */
3499 printk(KERN_WARNING
Michael Reedfd65e5e2009-04-08 14:33:48 -05003500 "qla1280: ISP invalid handle\n");
Linus Torvalds1da177e2005-04-16 15:20:36 -07003501 }
3502 }
3503 break;
3504
3505 case MBA_BUS_RESET: /* SCSI Bus Reset */
3506 ha->flags.reset_marker = 1;
3507 index = mailbox[6] & BIT_0;
3508 ha->bus_settings[index].reset_marker = 1;
3509
3510 printk(KERN_DEBUG "qla1280_isr(): index %i "
3511 "asynchronous BUS_RESET\n", index);
3512 break;
3513
3514 case MBA_SYSTEM_ERR: /* System Error */
3515 printk(KERN_WARNING
3516 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3517 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3518 mailbox[3]);
3519 break;
3520
3521 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3522 printk(KERN_WARNING
3523 "qla1280: ISP Request Transfer Error\n");
3524 break;
3525
3526 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3527 printk(KERN_WARNING
3528 "qla1280: ISP Response Transfer Error\n");
3529 break;
3530
3531 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3532 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3533 break;
3534
3535 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3536 dprintk(2,
3537 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3538 break;
3539
3540 case MBA_DEVICE_RESET: /* Bus Device Reset */
3541 printk(KERN_INFO "qla1280_isr(): asynchronous "
3542 "BUS_DEVICE_RESET\n");
3543
3544 ha->flags.reset_marker = 1;
3545 index = mailbox[6] & BIT_0;
3546 ha->bus_settings[index].reset_marker = 1;
3547 break;
3548
3549 case MBA_BUS_MODE_CHANGE:
3550 dprintk(2,
3551 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3552 break;
3553
3554 default:
3555 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3556 if (mailbox[0] < MBA_ASYNC_EVENT) {
3557 wptr = &mailbox[0];
3558 memcpy((uint16_t *) ha->mailbox_out, wptr,
3559 MAILBOX_REGISTER_COUNT *
3560 sizeof(uint16_t));
3561
3562 if(ha->mailbox_wait != NULL)
3563 complete(ha->mailbox_wait);
3564 }
3565 break;
3566 }
3567 } else {
3568 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
3569 }
3570
3571 /*
3572 * We will receive interrupts during mailbox testing prior to
3573 * the card being marked online, hence the double check.
3574 */
3575 if (!(ha->flags.online && !ha->mailbox_wait)) {
3576 dprintk(2, "qla1280_isr: Response pointer Error\n");
3577 goto out;
3578 }
3579
3580 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3581 goto out;
3582
3583 while (ha->rsp_ring_index != mailbox[5]) {
3584 pkt = ha->response_ring_ptr;
3585
3586 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3587 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3588 dprintk(5,"qla1280_isr: response packet data\n");
3589 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3590
3591 if (pkt->entry_type == STATUS_TYPE) {
3592 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3593 || pkt->comp_status || pkt->entry_status) {
3594 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3595 "0x%x mailbox[5] = 0x%x, comp_status "
3596 "= 0x%x, scsi_status = 0x%x\n",
3597 ha->rsp_ring_index, mailbox[5],
3598 le16_to_cpu(pkt->comp_status),
3599 le16_to_cpu(pkt->scsi_status));
3600 }
3601 } else {
3602 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3603 "0x%x, mailbox[5] = 0x%x\n",
3604 ha->rsp_ring_index, mailbox[5]);
3605 dprintk(2, "qla1280_isr: response packet data\n");
3606 qla1280_dump_buffer(2, (char *)pkt,
3607 RESPONSE_ENTRY_SIZE);
3608 }
3609
3610 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3611 dprintk(2, "status: Cmd %p, handle %i\n",
3612 ha->outstanding_cmds[pkt->handle]->cmd,
3613 pkt->handle);
3614 if (pkt->entry_type == STATUS_TYPE)
3615 qla1280_status_entry(ha, pkt, done_q);
3616 else
3617 qla1280_error_entry(ha, pkt, done_q);
3618 /* Adjust ring index. */
3619 ha->rsp_ring_index++;
3620 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3621 ha->rsp_ring_index = 0;
3622 ha->response_ring_ptr = ha->response_ring;
3623 } else
3624 ha->response_ring_ptr++;
3625 WRT_REG_WORD(&reg->mailbox5, ha->rsp_ring_index);
3626 }
3627 }
3628
3629 out:
3630 LEAVE("qla1280_isr");
3631}
3632
3633/*
3634 * qla1280_rst_aen
3635 * Processes asynchronous reset.
3636 *
3637 * Input:
3638 * ha = adapter block pointer.
3639 */
3640static void
3641qla1280_rst_aen(struct scsi_qla_host *ha)
3642{
3643 uint8_t bus;
3644
3645 ENTER("qla1280_rst_aen");
3646
3647 if (ha->flags.online && !ha->flags.reset_active &&
3648 !ha->flags.abort_isp_active) {
3649 ha->flags.reset_active = 1;
3650 while (ha->flags.reset_marker) {
3651 /* Issue marker command. */
3652 ha->flags.reset_marker = 0;
3653 for (bus = 0; bus < ha->ports &&
3654 !ha->flags.reset_marker; bus++) {
3655 if (ha->bus_settings[bus].reset_marker) {
3656 ha->bus_settings[bus].reset_marker = 0;
3657 qla1280_marker(ha, bus, 0, 0,
3658 MK_SYNC_ALL);
3659 }
3660 }
3661 }
3662 }
3663
3664 LEAVE("qla1280_rst_aen");
3665}
3666
3667
Linus Torvalds1da177e2005-04-16 15:20:36 -07003668/*
3669 * qla1280_status_entry
3670 * Processes received ISP status entry.
3671 *
3672 * Input:
3673 * ha = adapter block pointer.
3674 * pkt = entry pointer.
3675 * done_q = done queue.
3676 */
3677static void
3678qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3679 struct list_head *done_q)
3680{
3681 unsigned int bus, target, lun;
3682 int sense_sz;
3683 struct srb *sp;
3684 struct scsi_cmnd *cmd;
3685 uint32_t handle = le32_to_cpu(pkt->handle);
3686 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3687 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3688
3689 ENTER("qla1280_status_entry");
3690
3691 /* Validate handle. */
3692 if (handle < MAX_OUTSTANDING_COMMANDS)
3693 sp = ha->outstanding_cmds[handle];
3694 else
3695 sp = NULL;
3696
3697 if (!sp) {
3698 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3699 goto out;
3700 }
3701
3702 /* Free outstanding command slot. */
3703 ha->outstanding_cmds[handle] = NULL;
3704
3705 cmd = sp->cmd;
3706
3707 /* Generate LU queue on cntrl, target, LUN */
3708 bus = SCSI_BUS_32(cmd);
3709 target = SCSI_TCN_32(cmd);
3710 lun = SCSI_LUN_32(cmd);
3711
3712 if (comp_status || scsi_status) {
3713 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3714 "0x%x, handle = 0x%x\n", comp_status,
3715 scsi_status, handle);
3716 }
3717
Jeremy Higdon 7d0e11f2005-05-01 05:18:48 -07003718 /* Target busy or queue full */
3719 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3720 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3721 CMD_RESULT(cmd) = scsi_status & 0xff;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003722 } else {
3723
3724 /* Save ISP completion status */
3725 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3726
Christoph Hellwig d6db3e8d2005-07-04 17:48:36 +02003727 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003728 if (comp_status != CS_ARS_FAILED) {
3729 uint16_t req_sense_length =
3730 le16_to_cpu(pkt->req_sense_length);
3731 if (req_sense_length < CMD_SNSLEN(cmd))
3732 sense_sz = req_sense_length;
3733 else
3734 /*
3735 * scsi_cmnd->sense_buffer is
3736 * 64 bytes, why only copy 63?
3737 * This looks wrong! /Jes
3738 */
3739 sense_sz = CMD_SNSLEN(cmd) - 1;
3740
3741 memcpy(cmd->sense_buffer,
3742 &pkt->req_sense_data, sense_sz);
3743 } else
3744 sense_sz = 0;
3745 memset(cmd->sense_buffer + sense_sz, 0,
FUJITA Tomonorib80ca4f2008-01-13 15:46:13 +09003746 SCSI_SENSE_BUFFERSIZE - sense_sz);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003747
3748 dprintk(2, "qla1280_status_entry: Check "
3749 "condition Sense data, b %i, t %i, "
3750 "l %i\n", bus, target, lun);
3751 if (sense_sz)
3752 qla1280_dump_buffer(2,
3753 (char *)cmd->sense_buffer,
3754 sense_sz);
3755 }
3756 }
3757
Michael Reed413e6e12009-04-08 14:34:33 -05003758 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3759
Linus Torvalds1da177e2005-04-16 15:20:36 -07003760 /* Place command on done queue. */
3761 list_add_tail(&sp->list, done_q);
3762 out:
3763 LEAVE("qla1280_status_entry");
3764}
3765
3766/*
3767 * qla1280_error_entry
3768 * Processes error entry.
3769 *
3770 * Input:
3771 * ha = adapter block pointer.
3772 * pkt = entry pointer.
3773 * done_q = done queue.
3774 */
3775static void
3776qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3777 struct list_head *done_q)
3778{
3779 struct srb *sp;
3780 uint32_t handle = le32_to_cpu(pkt->handle);
3781
3782 ENTER("qla1280_error_entry");
3783
3784 if (pkt->entry_status & BIT_3)
3785 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3786 else if (pkt->entry_status & BIT_2)
3787 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3788 else if (pkt->entry_status & BIT_1)
3789 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3790 else
3791 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3792
3793 /* Validate handle. */
3794 if (handle < MAX_OUTSTANDING_COMMANDS)
3795 sp = ha->outstanding_cmds[handle];
3796 else
3797 sp = NULL;
3798
3799 if (sp) {
3800 /* Free outstanding command slot. */
3801 ha->outstanding_cmds[handle] = NULL;
3802
3803 /* Bad payload or header */
3804 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3805 /* Bad payload or header, set error status. */
3806 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3807 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3808 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3809 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3810 } else {
3811 /* Set error status. */
3812 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3813 }
3814
Michael Reed413e6e12009-04-08 14:34:33 -05003815 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3816
Linus Torvalds1da177e2005-04-16 15:20:36 -07003817 /* Place command on done queue. */
3818 list_add_tail(&sp->list, done_q);
3819 }
3820#ifdef QLA_64BIT_PTR
3821 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3822 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3823 }
3824#endif
3825
3826 LEAVE("qla1280_error_entry");
3827}
3828
3829/*
3830 * qla1280_abort_isp
3831 * Resets ISP and aborts all outstanding commands.
3832 *
3833 * Input:
3834 * ha = adapter block pointer.
3835 *
3836 * Returns:
3837 * 0 = success
3838 */
3839static int
3840qla1280_abort_isp(struct scsi_qla_host *ha)
3841{
3842 struct device_reg __iomem *reg = ha->iobase;
3843 struct srb *sp;
3844 int status = 0;
3845 int cnt;
3846 int bus;
3847
3848 ENTER("qla1280_abort_isp");
3849
3850 if (ha->flags.abort_isp_active || !ha->flags.online)
3851 goto out;
3852
3853 ha->flags.abort_isp_active = 1;
3854
3855 /* Disable ISP interrupts. */
3856 qla1280_disable_intrs(ha);
3857 WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
3858 RD_REG_WORD(&reg->id_l);
3859
3860 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3861 ha->host_no);
3862 /* Dequeue all commands in outstanding command list. */
3863 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3864 struct scsi_cmnd *cmd;
3865 sp = ha->outstanding_cmds[cnt];
3866 if (sp) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07003867 cmd = sp->cmd;
3868 CMD_RESULT(cmd) = DID_RESET << 16;
Michael Reed413e6e12009-04-08 14:34:33 -05003869 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003870 ha->outstanding_cmds[cnt] = NULL;
Michael Reed413e6e12009-04-08 14:34:33 -05003871 list_add_tail(&sp->list, &ha->done_q);
Linus Torvalds1da177e2005-04-16 15:20:36 -07003872 }
3873 }
3874
Michael Reed413e6e12009-04-08 14:34:33 -05003875 qla1280_done(ha);
3876
Linus Torvalds1da177e2005-04-16 15:20:36 -07003877 status = qla1280_load_firmware(ha);
3878 if (status)
3879 goto out;
3880
3881 /* Setup adapter based on NVRAM parameters. */
3882 qla1280_nvram_config (ha);
3883
3884 status = qla1280_init_rings(ha);
3885 if (status)
3886 goto out;
3887
3888 /* Issue SCSI reset. */
3889 for (bus = 0; bus < ha->ports; bus++)
3890 qla1280_bus_reset(ha, bus);
3891
3892 ha->flags.abort_isp_active = 0;
3893 out:
3894 if (status) {
3895 printk(KERN_WARNING
3896 "qla1280: ISP error recovery failed, board disabled");
3897 qla1280_reset_adapter(ha);
3898 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3899 }
3900
3901 LEAVE("qla1280_abort_isp");
3902 return status;
3903}
3904
3905
3906/*
3907 * qla1280_debounce_register
3908 * Debounce register.
3909 *
3910 * Input:
3911 * port = register address.
3912 *
3913 * Returns:
3914 * register value.
3915 */
3916static u16
3917qla1280_debounce_register(volatile u16 __iomem * addr)
3918{
3919 volatile u16 ret;
3920 volatile u16 ret2;
3921
3922 ret = RD_REG_WORD(addr);
3923 ret2 = RD_REG_WORD(addr);
3924
3925 if (ret == ret2)
3926 return ret;
3927
3928 do {
3929 cpu_relax();
3930 ret = RD_REG_WORD(addr);
3931 ret2 = RD_REG_WORD(addr);
3932 } while (ret != ret2);
3933
3934 return ret;
3935}
3936
3937
3938/************************************************************************
3939 * qla1280_check_for_dead_scsi_bus *
3940 * *
3941 * This routine checks for a dead SCSI bus *
3942 ************************************************************************/
3943#define SET_SXP_BANK 0x0100
3944#define SCSI_PHASE_INVALID 0x87FF
3945static int
3946qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3947{
3948 uint16_t config_reg, scsi_control;
3949 struct device_reg __iomem *reg = ha->iobase;
3950
3951 if (ha->bus_settings[bus].scsi_bus_dead) {
3952 WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
3953 config_reg = RD_REG_WORD(&reg->cfg_1);
3954 WRT_REG_WORD(&reg->cfg_1, SET_SXP_BANK);
3955 scsi_control = RD_REG_WORD(&reg->scsiControlPins);
3956 WRT_REG_WORD(&reg->cfg_1, config_reg);
3957 WRT_REG_WORD(&reg->host_cmd, HC_RELEASE_RISC);
3958
3959 if (scsi_control == SCSI_PHASE_INVALID) {
3960 ha->bus_settings[bus].scsi_bus_dead = 1;
Linus Torvalds1da177e2005-04-16 15:20:36 -07003961 return 1; /* bus is dead */
3962 } else {
3963 ha->bus_settings[bus].scsi_bus_dead = 0;
3964 ha->bus_settings[bus].failed_reset_count = 0;
3965 }
3966 }
3967 return 0; /* bus is not dead */
3968}
3969
3970static void
3971qla1280_get_target_parameters(struct scsi_qla_host *ha,
3972 struct scsi_device *device)
3973{
3974 uint16_t mb[MAILBOX_REGISTER_COUNT];
3975 int bus, target, lun;
3976
3977 bus = device->channel;
3978 target = device->id;
3979 lun = device->lun;
3980
3981
3982 mb[0] = MBC_GET_TARGET_PARAMETERS;
3983 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3984 mb[1] <<= 8;
3985 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3986 &mb[0]);
3987
3988 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3989
3990 if (mb[3] != 0) {
3991 printk(" Sync: period %d, offset %d",
3992 (mb[3] & 0xff), (mb[3] >> 8));
3993 if (mb[2] & BIT_13)
3994 printk(", Wide");
3995 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3996 printk(", DT");
3997 } else
3998 printk(" Async");
3999
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05004000 if (device->simple_tags)
Linus Torvalds1da177e2005-04-16 15:20:36 -07004001 printk(", Tagged queuing: depth %d", device->queue_depth);
4002 printk("\n");
4003}
4004
4005
4006#if DEBUG_QLA1280
4007static void
4008__qla1280_dump_buffer(char *b, int size)
4009{
4010 int cnt;
4011 u8 c;
4012
4013 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
4014 "Bh Ch Dh Eh Fh\n");
4015 printk(KERN_DEBUG "---------------------------------------------"
4016 "------------------\n");
4017
4018 for (cnt = 0; cnt < size;) {
4019 c = *b++;
4020
4021 printk("0x%02x", c);
4022 cnt++;
4023 if (!(cnt % 16))
4024 printk("\n");
4025 else
4026 printk(" ");
4027 }
4028 if (cnt % 16)
4029 printk("\n");
4030}
4031
4032/**************************************************************************
4033 * ql1280_print_scsi_cmd
4034 *
4035 **************************************************************************/
4036static void
4037__qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
4038{
4039 struct scsi_qla_host *ha;
4040 struct Scsi_Host *host = CMD_HOST(cmd);
4041 struct srb *sp;
4042 /* struct scatterlist *sg; */
4043
4044 int i;
4045 ha = (struct scsi_qla_host *)host->hostdata;
4046
4047 sp = (struct srb *)CMD_SP(cmd);
4048 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
4049 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4050 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
4051 CMD_CDBLEN(cmd));
4052 printk(" CDB = ");
4053 for (i = 0; i < cmd->cmd_len; i++) {
4054 printk("0x%02x ", cmd->cmnd[i]);
4055 }
Jes Sorensen5c1da582007-11-09 14:40:41 +01004056 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004057 printk(" request buffer=0x%p, request buffer len=0x%x\n",
Jes Sorensen5c1da582007-11-09 14:40:41 +01004058 scsi_sglist(cmd), scsi_bufflen(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004059 /* if (cmd->use_sg)
4060 {
4061 sg = (struct scatterlist *) cmd->request_buffer;
4062 printk(" SG buffer: \n");
4063 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4064 } */
4065 printk(" tag=%d, transfersize=0x%x \n",
4066 cmd->tag, cmd->transfersize);
Matthew Wilcox12a44162007-09-18 19:54:43 -06004067 printk(" Pid=%li, SP=0x%p\n", cmd->serial_number, CMD_SP(cmd));
Linus Torvalds1da177e2005-04-16 15:20:36 -07004068 printk(" underflow size = 0x%x, direction=0x%x\n",
4069 cmd->underflow, cmd->sc_data_direction);
4070}
4071
4072/**************************************************************************
4073 * ql1280_dump_device
4074 *
4075 **************************************************************************/
4076static void
4077ql1280_dump_device(struct scsi_qla_host *ha)
4078{
4079
4080 struct scsi_cmnd *cp;
4081 struct srb *sp;
4082 int i;
4083
4084 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4085
4086 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4087 if ((sp = ha->outstanding_cmds[i]) == NULL)
4088 continue;
4089 if ((cp = sp->cmd) == NULL)
4090 continue;
4091 qla1280_print_scsi_cmd(1, cp);
4092 }
4093}
4094#endif
4095
4096
4097enum tokens {
4098 TOKEN_NVRAM,
4099 TOKEN_SYNC,
4100 TOKEN_WIDE,
4101 TOKEN_PPR,
4102 TOKEN_VERBOSE,
4103 TOKEN_DEBUG,
4104};
4105
4106struct setup_tokens {
4107 char *token;
4108 int val;
4109};
4110
4111static struct setup_tokens setup_token[] __initdata =
4112{
4113 { "nvram", TOKEN_NVRAM },
4114 { "sync", TOKEN_SYNC },
4115 { "wide", TOKEN_WIDE },
4116 { "ppr", TOKEN_PPR },
4117 { "verbose", TOKEN_VERBOSE },
4118 { "debug", TOKEN_DEBUG },
4119};
4120
4121
4122/**************************************************************************
4123 * qla1280_setup
4124 *
4125 * Handle boot parameters. This really needs to be changed so one
4126 * can specify per adapter parameters.
4127 **************************************************************************/
4128static int __init
4129qla1280_setup(char *s)
4130{
4131 char *cp, *ptr;
4132 unsigned long val;
4133 int toke;
4134
4135 cp = s;
4136
4137 while (cp && (ptr = strchr(cp, ':'))) {
4138 ptr++;
4139 if (!strcmp(ptr, "yes")) {
4140 val = 0x10000;
4141 ptr += 3;
4142 } else if (!strcmp(ptr, "no")) {
4143 val = 0;
4144 ptr += 2;
4145 } else
4146 val = simple_strtoul(ptr, &ptr, 0);
4147
4148 switch ((toke = qla1280_get_token(cp))) {
4149 case TOKEN_NVRAM:
4150 if (!val)
4151 driver_setup.no_nvram = 1;
4152 break;
4153 case TOKEN_SYNC:
4154 if (!val)
4155 driver_setup.no_sync = 1;
4156 else if (val != 0x10000)
4157 driver_setup.sync_mask = val;
4158 break;
4159 case TOKEN_WIDE:
4160 if (!val)
4161 driver_setup.no_wide = 1;
4162 else if (val != 0x10000)
4163 driver_setup.wide_mask = val;
4164 break;
4165 case TOKEN_PPR:
4166 if (!val)
4167 driver_setup.no_ppr = 1;
4168 else if (val != 0x10000)
4169 driver_setup.ppr_mask = val;
4170 break;
4171 case TOKEN_VERBOSE:
4172 qla1280_verbose = val;
4173 break;
4174 default:
4175 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4176 cp);
4177 }
4178
4179 cp = strchr(ptr, ';');
4180 if (cp)
4181 cp++;
4182 else {
4183 break;
4184 }
4185 }
4186 return 1;
4187}
4188
4189
Randy Dunlapf58f8312006-06-30 02:33:14 -07004190static int __init
Linus Torvalds1da177e2005-04-16 15:20:36 -07004191qla1280_get_token(char *str)
4192{
4193 char *sep;
4194 long ret = -1;
Tobias Klauser6391a112006-06-08 22:23:48 -07004195 int i;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004196
4197 sep = strchr(str, ':');
4198
4199 if (sep) {
Tobias Klauser6391a112006-06-08 22:23:48 -07004200 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004201 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4202 ret = setup_token[i].val;
4203 break;
4204 }
4205 }
4206 }
4207
4208 return ret;
4209}
4210
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05004211
Linus Torvalds1da177e2005-04-16 15:20:36 -07004212static struct scsi_host_template qla1280_driver_template = {
4213 .module = THIS_MODULE,
4214 .proc_name = "qla1280",
4215 .name = "Qlogic ISP 1280/12160",
4216 .info = qla1280_info,
4217 .slave_configure = qla1280_slave_configure,
4218 .queuecommand = qla1280_queuecommand,
4219 .eh_abort_handler = qla1280_eh_abort,
4220 .eh_device_reset_handler= qla1280_eh_device_reset,
4221 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4222 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4223 .bios_param = qla1280_biosparam,
4224 .can_queue = 0xfffff,
4225 .this_id = -1,
4226 .sg_tablesize = SG_ALL,
4227 .cmd_per_lun = 1,
4228 .use_clustering = ENABLE_CLUSTERING,
4229};
Jes Sorensen2dbb04c2006-01-16 11:49:29 -05004230
Linus Torvalds1da177e2005-04-16 15:20:36 -07004231
4232static int __devinit
4233qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4234{
4235 int devnum = id->driver_data;
4236 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4237 struct Scsi_Host *host;
4238 struct scsi_qla_host *ha;
4239 int error = -ENODEV;
4240
4241 /* Bypass all AMI SUBSYS VENDOR IDs */
4242 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4243 printk(KERN_INFO
4244 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4245 goto error;
4246 }
4247
4248 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4249 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4250
4251 if (pci_enable_device(pdev)) {
4252 printk(KERN_WARNING
4253 "qla1280: Failed to enabled pci device, aborting.\n");
4254 goto error;
4255 }
4256
4257 pci_set_master(pdev);
4258
4259 error = -ENOMEM;
4260 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4261 if (!host) {
4262 printk(KERN_WARNING
4263 "qla1280: Failed to register host, aborting.\n");
4264 goto error_disable_device;
4265 }
4266
4267 ha = (struct scsi_qla_host *)host->hostdata;
4268 memset(ha, 0, sizeof(struct scsi_qla_host));
4269
4270 ha->pdev = pdev;
4271 ha->devnum = devnum; /* specifies microcode load address */
4272
4273#ifdef QLA_64BIT_PTR
Yang Hongyang6a355282009-04-06 19:01:13 -07004274 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(64))) {
Yang Hongyang284901a2009-04-06 19:01:15 -07004275 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004276 printk(KERN_WARNING "scsi(%li): Unable to set a "
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004277 "suitable DMA mask - aborting\n", ha->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004278 error = -ENODEV;
Johannes Dickgrebereb7a1692007-10-03 13:22:19 +02004279 goto error_put_host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004280 }
4281 } else
4282 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4283 ha->host_no);
4284#else
Yang Hongyang284901a2009-04-06 19:01:15 -07004285 if (pci_set_dma_mask(ha->pdev, DMA_BIT_MASK(32))) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07004286 printk(KERN_WARNING "scsi(%li): Unable to set a "
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004287 "suitable DMA mask - aborting\n", ha->host_no);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004288 error = -ENODEV;
Johannes Dickgrebereb7a1692007-10-03 13:22:19 +02004289 goto error_put_host;
Linus Torvalds1da177e2005-04-16 15:20:36 -07004290 }
4291#endif
4292
4293 ha->request_ring = pci_alloc_consistent(ha->pdev,
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004294 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004295 &ha->request_dma);
4296 if (!ha->request_ring) {
4297 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4298 goto error_put_host;
4299 }
4300
4301 ha->response_ring = pci_alloc_consistent(ha->pdev,
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004302 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004303 &ha->response_dma);
4304 if (!ha->response_ring) {
4305 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4306 goto error_free_request_ring;
4307 }
4308
4309 ha->ports = bdp->numPorts;
4310
4311 ha->host = host;
4312 ha->host_no = host->host_no;
4313
4314 host->irq = pdev->irq;
4315 host->max_channel = bdp->numPorts - 1;
4316 host->max_lun = MAX_LUNS - 1;
4317 host->max_id = MAX_TARGETS;
4318 host->max_sectors = 1024;
4319 host->unique_id = host->host_no;
4320
Linus Torvalds1da177e2005-04-16 15:20:36 -07004321 error = -ENODEV;
4322
4323#if MEMORY_MAPPED_IO
Arjan van de Ven25729a72008-09-28 16:18:02 -07004324 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004325 if (!ha->mmpbase) {
4326 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4327 goto error_free_response_ring;
4328 }
4329
4330 host->base = (unsigned long)ha->mmpbase;
4331 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4332#else
4333 host->io_port = pci_resource_start(ha->pdev, 0);
4334 if (!request_region(host->io_port, 0xff, "qla1280")) {
4335 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4336 "0x%04lx-0x%04lx - already in use\n",
4337 host->io_port, host->io_port + 0xff);
4338 goto error_free_response_ring;
4339 }
4340
4341 ha->iobase = (struct device_reg *)host->io_port;
4342#endif
4343
4344 INIT_LIST_HEAD(&ha->done_q);
4345
4346 /* Disable ISP interrupts. */
4347 qla1280_disable_intrs(ha);
4348
Thomas Gleixner1d6f3592006-07-01 19:29:42 -07004349 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
Linus Torvalds1da177e2005-04-16 15:20:36 -07004350 "qla1280", ha)) {
4351 printk("qla1280 : Failed to reserve interrupt %d already "
4352 "in use\n", pdev->irq);
4353 goto error_release_region;
4354 }
4355
4356 /* load the F/W, read paramaters, and init the H/W */
4357 if (qla1280_initialize_adapter(ha)) {
4358 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4359 goto error_free_irq;
4360 }
4361
4362 /* set our host ID (need to do something about our two IDs) */
4363 host->this_id = ha->bus_settings[0].id;
4364
4365 pci_set_drvdata(pdev, host);
4366
Linus Torvalds1da177e2005-04-16 15:20:36 -07004367 error = scsi_add_host(host, &pdev->dev);
4368 if (error)
4369 goto error_disable_adapter;
4370 scsi_scan_host(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004371
4372 return 0;
4373
Linus Torvalds1da177e2005-04-16 15:20:36 -07004374 error_disable_adapter:
Christoph Hellwig 8af50dc2005-07-04 17:48:19 +02004375 qla1280_disable_intrs(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004376 error_free_irq:
4377 free_irq(pdev->irq, ha);
4378 error_release_region:
4379#if MEMORY_MAPPED_IO
4380 iounmap(ha->mmpbase);
4381#else
4382 release_region(host->io_port, 0xff);
4383#endif
4384 error_free_response_ring:
4385 pci_free_consistent(ha->pdev,
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004386 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004387 ha->response_ring, ha->response_dma);
4388 error_free_request_ring:
4389 pci_free_consistent(ha->pdev,
Christoph Hellwig 2b55cac2005-07-04 17:48:30 +02004390 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
Linus Torvalds1da177e2005-04-16 15:20:36 -07004391 ha->request_ring, ha->request_dma);
4392 error_put_host:
4393 scsi_host_put(host);
4394 error_disable_device:
4395 pci_disable_device(pdev);
4396 error:
4397 return error;
4398}
4399
4400
4401static void __devexit
4402qla1280_remove_one(struct pci_dev *pdev)
4403{
4404 struct Scsi_Host *host = pci_get_drvdata(pdev);
4405 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4406
Linus Torvalds1da177e2005-04-16 15:20:36 -07004407 scsi_remove_host(host);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004408
Christoph Hellwig 8af50dc2005-07-04 17:48:19 +02004409 qla1280_disable_intrs(ha);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004410
4411 free_irq(pdev->irq, ha);
4412
4413#if MEMORY_MAPPED_IO
4414 iounmap(ha->mmpbase);
4415#else
4416 release_region(host->io_port, 0xff);
4417#endif
4418
4419 pci_free_consistent(ha->pdev,
4420 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4421 ha->request_ring, ha->request_dma);
4422 pci_free_consistent(ha->pdev,
4423 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4424 ha->response_ring, ha->response_dma);
4425
4426 pci_disable_device(pdev);
4427
4428 scsi_host_put(host);
4429}
4430
Linus Torvalds1da177e2005-04-16 15:20:36 -07004431static struct pci_driver qla1280_pci_driver = {
4432 .name = "qla1280",
4433 .id_table = qla1280_pci_tbl,
4434 .probe = qla1280_probe_one,
4435 .remove = __devexit_p(qla1280_remove_one),
4436};
4437
4438static int __init
4439qla1280_init(void)
4440{
4441 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4442 printk(KERN_WARNING
4443 "qla1280: struct srb too big, aborting\n");
4444 return -EINVAL;
4445 }
4446
4447#ifdef MODULE
4448 /*
4449 * If we are called as a module, the qla1280 pointer may not be null
4450 * and it would point to our bootup string, just like on the lilo
4451 * command line. IF not NULL, then process this config string with
4452 * qla1280_setup
4453 *
4454 * Boot time Options
4455 * To add options at boot time add a line to your lilo.conf file like:
4456 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4457 * which will result in the first four devices on the first two
4458 * controllers being set to a tagged queue depth of 32.
4459 */
4460 if (qla1280)
4461 qla1280_setup(qla1280);
4462#endif
4463
Henrik Kretzschmardcbccbde2006-09-25 16:58:58 -07004464 return pci_register_driver(&qla1280_pci_driver);
Linus Torvalds1da177e2005-04-16 15:20:36 -07004465}
4466
4467static void __exit
4468qla1280_exit(void)
4469{
Michael Reed421e33d2010-03-23 15:00:58 -05004470 int i;
4471
Linus Torvalds1da177e2005-04-16 15:20:36 -07004472 pci_unregister_driver(&qla1280_pci_driver);
Michael Reed421e33d2010-03-23 15:00:58 -05004473 /* release any allocated firmware images */
4474 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
4475 if (qla1280_fw_tbl[i].fw) {
4476 release_firmware(qla1280_fw_tbl[i].fw);
4477 qla1280_fw_tbl[i].fw = NULL;
4478 }
4479 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07004480}
4481
4482module_init(qla1280_init);
4483module_exit(qla1280_exit);
4484
Linus Torvalds1da177e2005-04-16 15:20:36 -07004485
4486MODULE_AUTHOR("Qlogic & Jes Sorensen");
4487MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4488MODULE_LICENSE("GPL");
Jaswinder Singh Rajput1bfa11d2009-04-02 11:13:17 +05304489MODULE_FIRMWARE("qlogic/1040.bin");
4490MODULE_FIRMWARE("qlogic/1280.bin");
4491MODULE_FIRMWARE("qlogic/12160.bin");
Linus Torvalds1da177e2005-04-16 15:20:36 -07004492MODULE_VERSION(QLA1280_VERSION);
4493
4494/*
4495 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4496 * Emacs will notice this stuff at the end of the file and automatically
4497 * adjust the settings for this buffer only. This must remain at the end
4498 * of the file.
4499 * ---------------------------------------------------------------------------
4500 * Local variables:
4501 * c-basic-offset: 8
4502 * tab-width: 8
4503 * End:
4504 */