projects / linux-block.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
treewide: Replace GPLv2 boilerplate/reference with SPDX - rule 118
[linux-block.git] / drivers / scsi / qla1280.c
CommitLineData
3e0a4e85 1// SPDX-License-Identifier: GPL-2.0-or-later
1da177e4
LT		 2/******************************************************************************
3* QLOGIC LINUX SOFTWARE
4*
5* QLogic QLA1280 (Ultra2) and QLA12160 (Ultra3) SCSI driver
6* Copyright (C) 2000 Qlogic Corporation (www.qlogic.com)
7* Copyright (C) 2001-2004 Jes Sorensen, Wild Open Source Inc.
8* Copyright (C) 2003-2004 Christoph Hellwig
9*
1da177e4 10******************************************************************************/
421e33d0 11#define QLA1280_VERSION "3.27.1"
1da177e4
LT		 12/*****************************************************************************
13 Revision History:
421e33d0
MR		 14 Rev 3.27.1, February 8, 2010, Michael Reed
15 - Retain firmware image for error recovery.
413e6e18
MR		 16 Rev 3.27, February 10, 2009, Michael Reed
17 - General code cleanup.
18 - Improve error recovery.
2dbb04c6
JS		 19 Rev 3.26, January 16, 2006 Jes Sorensen
20 - Ditch all < 2.6 support
1da177e4
LT		 21 Rev 3.25.1, February 10, 2005 Christoph Hellwig
22 - use pci_map_single to map non-S/G requests
23 - remove qla1280_proc_info
24 Rev 3.25, September 28, 2004, Christoph Hellwig
25 - add support for ISP1020/1040
26 - don't include "scsi.h" anymore for 2.6.x
27 Rev 3.24.4 June 7, 2004 Christoph Hellwig
28 - restructure firmware loading, cleanup initialization code
29 - prepare support for ISP1020/1040 chips
30 Rev 3.24.3 January 19, 2004, Jes Sorensen
31 - Handle PCI DMA mask settings correctly
32 - Correct order of error handling in probe_one, free_irq should not
33 be called if request_irq failed
34 Rev 3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
35 - Big endian fixes (James)
36 - Remove bogus IOCB content on zero data transfer commands (Andrew)
37 Rev 3.24.1 January 5, 2004, Jes Sorensen
38 - Initialize completion queue to avoid OOPS on probe
39 - Handle interrupts during mailbox testing
40 Rev 3.24 November 17, 2003, Christoph Hellwig
41 - use struct list_head for completion queue
42 - avoid old Scsi_FOO typedefs
43 - cleanup 2.4 compat glue a bit
44 - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
45 - make initialization for memory mapped vs port I/O more similar
46 - remove broken pci config space manipulation
47 - kill more cruft
48 - this is an almost perfect 2.6 scsi driver now! ;)
49 Rev 3.23.39 December 17, 2003, Jes Sorensen
50 - Delete completion queue from srb if mailbox command failed to
51 to avoid qla1280_done completeting qla1280_error_action's
52 obsolete context
53 - Reduce arguments for qla1280_done
54 Rev 3.23.38 October 18, 2003, Christoph Hellwig
55 - Convert to new-style hotplugable driver for 2.6
56 - Fix missing scsi_unregister/scsi_host_put on HBA removal
57 - Kill some more cruft
58 Rev 3.23.37 October 1, 2003, Jes Sorensen
59 - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
60 random CONFIG option
61 - Clean up locking in probe path
62 Rev 3.23.36 October 1, 2003, Christoph Hellwig
63 - queuecommand only ever receives new commands - clear flags
64 - Reintegrate lost fixes from Linux 2.5
65 Rev 3.23.35 August 14, 2003, Jes Sorensen
66 - Build against 2.6
67 Rev 3.23.34 July 23, 2003, Jes Sorensen
68 - Remove pointless TRUE/FALSE macros
69 - Clean up vchan handling
70 Rev 3.23.33 July 3, 2003, Jes Sorensen
71 - Don't define register access macros before define determining MMIO.
25985edc 72 This just happened to work out on ia64 but not elsewhere.
1da177e4
LT		 73 - Don't try and read from the card while it is in reset as
74 it won't respond and causes an MCA
75 Rev 3.23.32 June 23, 2003, Jes Sorensen
76 - Basic support for boot time arguments
77 Rev 3.23.31 June 8, 2003, Jes Sorensen
78 - Reduce boot time messages
79 Rev 3.23.30 June 6, 2003, Jes Sorensen
80 - Do not enable sync/wide/ppr before it has been determined
81 that the target device actually supports it
82 - Enable DMA arbitration for multi channel controllers
83 Rev 3.23.29 June 3, 2003, Jes Sorensen
84 - Port to 2.5.69
85 Rev 3.23.28 June 3, 2003, Jes Sorensen
86 - Eliminate duplicate marker commands on bus resets
87 - Handle outstanding commands appropriately on bus/device resets
88 Rev 3.23.27 May 28, 2003, Jes Sorensen
89 - Remove bogus input queue code, let the Linux SCSI layer do the work
90 - Clean up NVRAM handling, only read it once from the card
91 - Add a number of missing default nvram parameters
92 Rev 3.23.26 Beta May 28, 2003, Jes Sorensen
93 - Use completion queue for mailbox commands instead of busy wait
94 Rev 3.23.25 Beta May 27, 2003, James Bottomley
95 - Migrate to use new error handling code
96 Rev 3.23.24 Beta May 21, 2003, James Bottomley
97 - Big endian support
98 - Cleanup data direction code
99 Rev 3.23.23 Beta May 12, 2003, Jes Sorensen
100 - Switch to using MMIO instead of PIO
101 Rev 3.23.22 Beta April 15, 2003, Jes Sorensen
102 - Fix PCI parity problem with 12160 during reset.
103 Rev 3.23.21 Beta April 14, 2003, Jes Sorensen
104 - Use pci_map_page()/pci_unmap_page() instead of map_single version.
105 Rev 3.23.20 Beta April 9, 2003, Jes Sorensen
106 - Remove < 2.4.x support
107 - Introduce HOST_LOCK to make the spin lock changes portable.
108 - Remove a bunch of idiotic and unnecessary typedef's
109 - Kill all leftovers of target-mode support which never worked anyway
110 Rev 3.23.19 Beta April 11, 2002, Linus Torvalds
111 - Do qla1280_pci_config() before calling request_irq() and
112 request_region()
113 - Use pci_dma_hi32() to handle upper word of DMA addresses instead
114 of large shifts
115 - Hand correct arguments to free_irq() in case of failure
116 Rev 3.23.18 Beta April 11, 2002, Jes Sorensen
117 - Run source through Lindent and clean up the output
118 Rev 3.23.17 Beta April 11, 2002, Jes Sorensen
119 - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
120 Rev 3.23.16 Beta March 19, 2002, Jes Sorensen
121 - Rely on mailbox commands generating interrupts - do not
122 run qla1280_isr() from ql1280_mailbox_command()
123 - Remove device_reg_t
124 - Integrate ql12160_set_target_parameters() with 1280 version
125 - Make qla1280_setup() non static
126 - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
c3af1715 127 sent to the card - this command pauses the firmware!!!
1da177e4
LT		 128 Rev 3.23.15 Beta March 19, 2002, Jes Sorensen
129 - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
130 - Remove a pile of pointless and confusing (srb_t **) and
131 (scsi_lu_t *) typecasts
132 - Explicit mark that we do not use the new error handling (for now)
133 - Remove scsi_qla_host_t and use 'struct' instead
134 - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
135 pci_64bit_slot flags which weren't used for anything anyway
136 - Grab host->host_lock while calling qla1280_isr() from abort()
137 - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
138 do not need to save/restore flags in the interrupt handler
139 - Enable interrupts early (before any mailbox access) in preparation
140 for cleaning up the mailbox handling
141 Rev 3.23.14 Beta March 14, 2002, Jes Sorensen
142 - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
143 it with proper use of dprintk().
144 - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
145 a debug level argument to determine if data is to be printed
146 - Add KERN_* info to printk()
147 Rev 3.23.13 Beta March 14, 2002, Jes Sorensen
148 - Significant cosmetic cleanups
149 - Change debug code to use dprintk() and remove #if mess
150 Rev 3.23.12 Beta March 13, 2002, Jes Sorensen
151 - More cosmetic cleanups, fix places treating return as function
152 - use cpu_relax() in qla1280_debounce_register()
153 Rev 3.23.11 Beta March 13, 2002, Jes Sorensen
154 - Make it compile under 2.5.5
155 Rev 3.23.10 Beta October 1, 2001, Jes Sorensen
156 - Do no typecast short * to long * in QL1280BoardTbl, this
157 broke miserably on big endian boxes
158 Rev 3.23.9 Beta September 30, 2001, Jes Sorensen
159 - Remove pre 2.2 hack for checking for reentrance in interrupt handler
160 - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
161 unsigned int to match the types from struct scsi_cmnd
162 Rev 3.23.8 Beta September 29, 2001, Jes Sorensen
163 - Remove bogus timer_t typedef from qla1280.h
164 - Remove obsolete pre 2.2 PCI setup code, use proper #define's
165 for PCI_ values, call pci_set_master()
166 - Fix memleak of qla1280_buffer on module unload
167 - Only compile module parsing code #ifdef MODULE - should be
168 changed to use individual MODULE_PARM's later
169 - Remove dummy_buffer that was never modified nor printed
170 - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
171 #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
172 - Remove \r from print statements, this is Linux, not DOS
173 - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
174 dummy macros
175 - Remove C++ compile hack in header file as Linux driver are not
176 supposed to be compiled as C++
177 - Kill MS_64BITS macro as it makes the code more readable
178 - Remove unnecessary flags.in_interrupts bit
179 Rev 3.23.7 Beta August 20, 2001, Jes Sorensen
180 - Dont' check for set flags on q->q_flag one by one in qla1280_next()
181 - Check whether the interrupt was generated by the QLA1280 before
182 doing any processing
183 - qla1280_status_entry(): Only zero out part of sense_buffer that
184 is not being copied into
185 - Remove more superflouous typecasts
186 - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
187 Rev 3.23.6 Beta August 20, 2001, Tony Luck, Intel
188 - Don't walk the entire list in qla1280_putq_t() just to directly
189 grab the pointer to the last element afterwards
190 Rev 3.23.5 Beta August 9, 2001, Jes Sorensen
1d6f359a 191 - Don't use IRQF_DISABLED, it's use is deprecated for this kinda driver
1da177e4
LT		 192 Rev 3.23.4 Beta August 8, 2001, Jes Sorensen
193 - Set dev->max_sectors to 1024
194 Rev 3.23.3 Beta August 6, 2001, Jes Sorensen
195 - Provide compat macros for pci_enable_device(), pci_find_subsys()
196 and scsi_set_pci_device()
197 - Call scsi_set_pci_device() for all devices
198 - Reduce size of kernel version dependent device probe code
199 - Move duplicate probe/init code to separate function
200 - Handle error if qla1280_mem_alloc() fails
201 - Kill OFFSET() macro and use Linux's PCI definitions instead
202 - Kill private structure defining PCI config space (struct config_reg)
203 - Only allocate I/O port region if not in MMIO mode
204 - Remove duplicate (unused) sanity check of sife of srb_t
205 Rev 3.23.2 Beta August 6, 2001, Jes Sorensen
206 - Change home-brew memset() implementations to use memset()
207 - Remove all references to COMTRACE() - accessing a PC's COM2 serial
208 port directly is not legal under Linux.
209 Rev 3.23.1 Beta April 24, 2001, Jes Sorensen
210 - Remove pre 2.2 kernel support
211 - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
212 - Fix MMIO access to use readl/writel instead of directly
213 dereferencing pointers
214 - Nuke MSDOS debugging code
215 - Change true/false data types to int from uint8_t
216 - Use int for counters instead of uint8_t etc.
217 - Clean up size & byte order conversion macro usage
218 Rev 3.23 Beta January 11, 2001 BN Qlogic
219 - Added check of device_id when handling non
220 QLA12160s during detect().
221 Rev 3.22 Beta January 5, 2001 BN Qlogic
222 - Changed queue_task() to schedule_task()
223 for kernels 2.4.0 and higher.
224 Note: 2.4.0-testxx kernels released prior to
225 the actual 2.4.0 kernel release on January 2001
226 will get compile/link errors with schedule_task().
227 Please update your kernel to released 2.4.0 level,
228 or comment lines in this file flagged with 3.22
229 to resolve compile/link error of schedule_task().
230 - Added -DCONFIG_SMP in addition to -D__SMP__
231 in Makefile for 2.4.0 builds of driver as module.
232 Rev 3.21 Beta January 4, 2001 BN Qlogic
233 - Changed criteria of 64/32 Bit mode of HBA
234 operation according to BITS_PER_LONG rather
235 than HBA's NVRAM setting of >4Gig memory bit;
236 so that the HBA auto-configures without the need
237 to setup each system individually.
238 Rev 3.20 Beta December 5, 2000 BN Qlogic
239 - Added priority handling to IA-64 onboard SCSI
240 ISP12160 chip for kernels greater than 2.3.18.
241 - Added irqrestore for qla1280_intr_handler.
242 - Enabled /proc/scsi/qla1280 interface.
243 - Clear /proc/scsi/qla1280 counters in detect().
244 Rev 3.19 Beta October 13, 2000 BN Qlogic
245 - Declare driver_template for new kernel
246 (2.4.0 and greater) scsi initialization scheme.
247 - Update /proc/scsi entry for 2.3.18 kernels and
248 above as qla1280
249 Rev 3.18 Beta October 10, 2000 BN Qlogic
250 - Changed scan order of adapters to map
251 the QLA12160 followed by the QLA1280.
252 Rev 3.17 Beta September 18, 2000 BN Qlogic
253 - Removed warnings for 32 bit 2.4.x compiles
254 - Corrected declared size for request and response
255 DMA addresses that are kept in each ha
256 Rev. 3.16 Beta August 25, 2000 BN Qlogic
257 - Corrected 64 bit addressing issue on IA-64
258 where the upper 32 bits were not properly
259 passed to the RISC engine.
260 Rev. 3.15 Beta August 22, 2000 BN Qlogic
261 - Modified qla1280_setup_chip to properly load
262 ISP firmware for greater that 4 Gig memory on IA-64
263 Rev. 3.14 Beta August 16, 2000 BN Qlogic
264 - Added setting of dma_mask to full 64 bit
265 if flags.enable_64bit_addressing is set in NVRAM
266 Rev. 3.13 Beta August 16, 2000 BN Qlogic
267 - Use new PCI DMA mapping APIs for 2.4.x kernel
268 Rev. 3.12 July 18, 2000 Redhat & BN Qlogic
269 - Added check of pci_enable_device to detect() for 2.3.x
270 - Use pci_resource_start() instead of
271 pdev->resource[0].start in detect() for 2.3.x
272 - Updated driver version
273 Rev. 3.11 July 14, 2000 BN Qlogic
274 - Updated SCSI Firmware to following versions:
275 qla1x80: 8.13.08
276 qla1x160: 10.04.08
277 - Updated driver version to 3.11
278 Rev. 3.10 June 23, 2000 BN Qlogic
279 - Added filtering of AMI SubSys Vendor ID devices
280 Rev. 3.9
281 - DEBUG_QLA1280 undefined and new version BN Qlogic
282 Rev. 3.08b May 9, 2000 MD Dell
283 - Added logic to check against AMI subsystem vendor ID
284 Rev. 3.08 May 4, 2000 DG Qlogic
285 - Added logic to check for PCI subsystem ID.
286 Rev. 3.07 Apr 24, 2000 DG & BN Qlogic
287 - Updated SCSI Firmware to following versions:
288 qla12160: 10.01.19
289 qla1280: 8.09.00
290 Rev. 3.06 Apr 12, 2000 DG & BN Qlogic
291 - Internal revision; not released
292 Rev. 3.05 Mar 28, 2000 DG & BN Qlogic
293 - Edit correction for virt_to_bus and PROC.
294 Rev. 3.04 Mar 28, 2000 DG & BN Qlogic
295 - Merge changes from ia64 port.
296 Rev. 3.03 Mar 28, 2000 BN Qlogic
297 - Increase version to reflect new code drop with compile fix
298 of issue with inclusion of linux/spinlock for 2.3 kernels
299 Rev. 3.02 Mar 15, 2000 BN Qlogic
300 - Merge qla1280_proc_info from 2.10 code base
301 Rev. 3.01 Feb 10, 2000 BN Qlogic
302 - Corrected code to compile on a 2.2.x kernel.
303 Rev. 3.00 Jan 17, 2000 DG Qlogic
304 - Added 64-bit support.
305 Rev. 2.07 Nov 9, 1999 DG Qlogic
306 - Added new routine to set target parameters for ISP12160.
307 Rev. 2.06 Sept 10, 1999 DG Qlogic
308 - Added support for ISP12160 Ultra 3 chip.
309 Rev. 2.03 August 3, 1999 Fred Lewis, Intel DuPont
310 - Modified code to remove errors generated when compiling with
311 Cygnus IA64 Compiler.
312 - Changed conversion of pointers to unsigned longs instead of integers.
313 - Changed type of I/O port variables from uint32_t to unsigned long.
314 - Modified OFFSET macro to work with 64-bit as well as 32-bit.
315 - Changed sprintf and printk format specifiers for pointers to %p.
316 - Changed some int to long type casts where needed in sprintf & printk.
317 - Added l modifiers to sprintf and printk format specifiers for longs.
318 - Removed unused local variables.
319 Rev. 1.20 June 8, 1999 DG, Qlogic
320 Changes to support RedHat release 6.0 (kernel 2.2.5).
321 - Added SCSI exclusive access lock (io_request_lock) when accessing
322 the adapter.
323 - Added changes for the new LINUX interface template. Some new error
324 handling routines have been added to the template, but for now we
325 will use the old ones.
326 - Initial Beta Release.
327*****************************************************************************/
328
329
1da177e4
LT		 330#include <linux/module.h>
331
1da177e4
LT		 332#include <linux/types.h>
333#include <linux/string.h>
334#include <linux/errno.h>
335#include <linux/kernel.h>
336#include <linux/ioport.h>
337#include <linux/delay.h>
338#include <linux/timer.h>
1da177e4
LT		 339#include <linux/pci.h>
340#include <linux/proc_fs.h>
341#include <linux/stat.h>
1da177e4
LT		 342#include <linux/pci_ids.h>
343#include <linux/interrupt.h>
344#include <linux/init.h>
910638ae 345#include <linux/dma-mapping.h>
1bfa11db 346#include <linux/firmware.h>
1da177e4
LT		 347
348#include <asm/io.h>
349#include <asm/irq.h>
350#include <asm/byteorder.h>
351#include <asm/processor.h>
352#include <asm/types.h>
1da177e4 353
1da177e4
LT		 354#include <scsi/scsi.h>
355#include <scsi/scsi_cmnd.h>
356#include <scsi/scsi_device.h>
357#include <scsi/scsi_host.h>
358#include <scsi/scsi_tcq.h>
1da177e4
LT		 359
360#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
361#include <asm/sn/io.h>
362#endif
363
1da177e4
LT		 364
365/*
366 * Compile time Options:
367 * 0 - Disable and 1 - Enable
368 */
369#define DEBUG_QLA1280_INTR 0
370#define DEBUG_PRINT_NVRAM 0
371#define DEBUG_QLA1280 0
372
1da177e4 373#define MEMORY_MAPPED_IO 1
1da177e4 374
1da177e4 375#include "qla1280.h"
1da177e4 376
ac4b1657 377#ifdef CONFIG_ARCH_DMA_ADDR_T_64BIT
1da177e4
LT		 378#define QLA_64BIT_PTR 1
379#endif
380
1da177e4
LT		 381#define NVRAM_DELAY() udelay(500) /* 2 microseconds */
382
1da177e4
LT		 383#if defined(__ia64__) && !defined(ia64_platform_is)
384#define ia64_platform_is(foo) (!strcmp(x, platform_name))
385#endif
386
387
388#define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
389#define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
390 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
391#define IS_ISP1x160(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
392 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
393
394
395static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
396static void qla1280_remove_one(struct pci_dev *);
397
398/*
399 * QLogic Driver Support Function Prototypes.
400 */
401static void qla1280_done(struct scsi_qla_host *);
1da177e4
LT		 402static int qla1280_get_token(char *);
403static int qla1280_setup(char *s) __init;
404
405/*
406 * QLogic ISP1280 Hardware Support Function Prototypes.
407 */
408static int qla1280_load_firmware(struct scsi_qla_host *);
409static int qla1280_init_rings(struct scsi_qla_host *);
410static int qla1280_nvram_config(struct scsi_qla_host *);
411static int qla1280_mailbox_command(struct scsi_qla_host *,
412 uint8_t, uint16_t *);
413static int qla1280_bus_reset(struct scsi_qla_host *, int);
414static int qla1280_device_reset(struct scsi_qla_host *, int, int);
1da177e4
LT		 415static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
416static int qla1280_abort_isp(struct scsi_qla_host *);
417#ifdef QLA_64BIT_PTR
418static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
419#else
420static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
421#endif
422static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
423static void qla1280_poll(struct scsi_qla_host *);
424static void qla1280_reset_adapter(struct scsi_qla_host *);
425static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
426static void qla1280_isp_cmd(struct scsi_qla_host *);
427static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
428static void qla1280_rst_aen(struct scsi_qla_host *);
429static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
430 struct list_head *);
431static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
432 struct list_head *);
433static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
434static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
435static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
436static request_t *qla1280_req_pkt(struct scsi_qla_host *);
437static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
438 unsigned int);
439static void qla1280_get_target_parameters(struct scsi_qla_host *,
440 struct scsi_device *);
441static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
442
443
444static struct qla_driver_setup driver_setup;
445
446/*
447 * convert scsi data direction to request_t control flags
448 */
449static inline uint16_t
450qla1280_data_direction(struct scsi_cmnd *cmnd)
451{
452 switch(cmnd->sc_data_direction) {
453 case DMA_FROM_DEVICE:
454 return BIT_5;
455 case DMA_TO_DEVICE:
456 return BIT_6;
457 case DMA_BIDIRECTIONAL:
458 return BIT_5 | BIT_6;
459 /*
460 * We could BUG() on default here if one of the four cases aren't
461 * met, but then again if we receive something like that from the
462 * SCSI layer we have more serious problems. This shuts up GCC.
463 */
464 case DMA_NONE:
465 default:
466 return 0;
467 }
468}
469
470#if DEBUG_QLA1280
471static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
472static void __qla1280_dump_buffer(char *, int);
473#endif
474
475
476/*
477 * insmod needs to find the variable and make it point to something
478 */
479#ifdef MODULE
480static char *qla1280;
481
482/* insmod qla1280 options=verbose" */
483module_param(qla1280, charp, 0);
484#else
485__setup("qla1280=", qla1280_setup);
486#endif
487
488
489/*
490 * We use the scsi_pointer structure that's included with each scsi_command
491 * to overlay our struct srb over it. qla1280_init() checks that a srb is not
492 * bigger than a scsi_pointer.
493 */
494
495#define CMD_SP(Cmnd) &Cmnd->SCp
496#define CMD_CDBLEN(Cmnd) Cmnd->cmd_len
497#define CMD_CDBP(Cmnd) Cmnd->cmnd
498#define CMD_SNSP(Cmnd) Cmnd->sense_buffer
b80ca4f7 499#define CMD_SNSLEN(Cmnd) SCSI_SENSE_BUFFERSIZE
1da177e4
LT		 500#define CMD_RESULT(Cmnd) Cmnd->result
501#define CMD_HANDLE(Cmnd) Cmnd->host_scribble
1da177e4 502#define CMD_REQUEST(Cmnd) Cmnd->request->cmd
1da177e4
LT		 503
504#define CMD_HOST(Cmnd) Cmnd->device->host
505#define SCSI_BUS_32(Cmnd) Cmnd->device->channel
506#define SCSI_TCN_32(Cmnd) Cmnd->device->id
507#define SCSI_LUN_32(Cmnd) Cmnd->device->lun
508
509
510/*****************************************/
511/* ISP Boards supported by this driver */
512/*****************************************/
513
514struct qla_boards {
421e33d0 515 char *name; /* Board ID String */
1da177e4 516 int numPorts; /* Number of SCSI ports */
421e33d0 517 int fw_index; /* index into qla1280_fw_tbl for firmware */
1da177e4
LT		 518};
519
520/* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
521static struct pci_device_id qla1280_pci_tbl[] = {
522 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
523 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
1da177e4
LT		 524 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
525 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
1da177e4
LT		 526 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
527 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
528 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
529 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
530 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
531 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
532 {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
533 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
534 {0,}
535};
536MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
537
421e33d0
MR		 538DEFINE_MUTEX(qla1280_firmware_mutex);
539
540struct qla_fw {
541 char *fwname;
542 const struct firmware *fw;
543};
544
545#define QL_NUM_FW_IMAGES 3
546
547struct qla_fw qla1280_fw_tbl[QL_NUM_FW_IMAGES] = {
548 {"qlogic/1040.bin", NULL}, /* image 0 */
549 {"qlogic/1280.bin", NULL}, /* image 1 */
550 {"qlogic/12160.bin", NULL}, /* image 2 */
551};
552
553/* NOTE: Order of boards in this table must match order in qla1280_pci_tbl */
1da177e4 554static struct qla_boards ql1280_board_tbl[] = {
421e33d0
MR		 555 {.name = "QLA12160", .numPorts = 2, .fw_index = 2},
556 {.name = "QLA1040" , .numPorts = 1, .fw_index = 0},
557 {.name = "QLA1080" , .numPorts = 1, .fw_index = 1},
558 {.name = "QLA1240" , .numPorts = 2, .fw_index = 1},
559 {.name = "QLA1280" , .numPorts = 2, .fw_index = 1},
560 {.name = "QLA10160", .numPorts = 1, .fw_index = 2},
561 {.name = " ", .numPorts = 0, .fw_index = -1},
1da177e4
LT		 562};
563
564static int qla1280_verbose = 1;
565
566#if DEBUG_QLA1280
567static int ql_debug_level = 1;
568#define dprintk(level, format, a...) \
569 do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
570#define qla1280_dump_buffer(level, buf, size) \
571 if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
572#define qla1280_print_scsi_cmd(level, cmd) \
573 if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
574#else
575#define ql_debug_level 0
576#define dprintk(level, format, a...) do{}while(0)
577#define qla1280_dump_buffer(a, b, c) do{}while(0)
578#define qla1280_print_scsi_cmd(a, b) do{}while(0)
579#endif
580
581#define ENTER(x) dprintk(3, "qla1280 : Entering %s()\n", x);
582#define LEAVE(x) dprintk(3, "qla1280 : Leaving %s()\n", x);
583#define ENTER_INTR(x) dprintk(4, "qla1280 : Entering %s()\n", x);
584#define LEAVE_INTR(x) dprintk(4, "qla1280 : Leaving %s()\n", x);
585
586
587static int qla1280_read_nvram(struct scsi_qla_host *ha)
588{
589 uint16_t *wptr;
590 uint8_t chksum;
591 int cnt, i;
592 struct nvram *nv;
593
594 ENTER("qla1280_read_nvram");
595
596 if (driver_setup.no_nvram)
597 return 1;
598
599 printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
600
601 wptr = (uint16_t *)&ha->nvram;
602 nv = &ha->nvram;
603 chksum = 0;
604 for (cnt = 0; cnt < 3; cnt++) {
605 *wptr = qla1280_get_nvram_word(ha, cnt);
606 chksum += *wptr & 0xff;
607 chksum += (*wptr >> 8) & 0xff;
608 wptr++;
609 }
610
611 if (nv->id0 != 'I' || nv->id1 != 'S' ||
612 nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
613 dprintk(2, "Invalid nvram ID or version!\n");
614 chksum = 1;
615 } else {
616 for (; cnt < sizeof(struct nvram); cnt++) {
617 *wptr = qla1280_get_nvram_word(ha, cnt);
618 chksum += *wptr & 0xff;
619 chksum += (*wptr >> 8) & 0xff;
620 wptr++;
621 }
622 }
623
624 dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
625 " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
626 nv->version);
627
628
629 if (chksum) {
630 if (!driver_setup.no_nvram)
631 printk(KERN_WARNING "scsi(%ld): Unable to identify or "
632 "validate NVRAM checksum, using default "
633 "settings\n", ha->host_no);
634 ha->nvram_valid = 0;
635 } else
636 ha->nvram_valid = 1;
637
638 /* The firmware interface is, um, interesting, in that the
639 * actual firmware image on the chip is little endian, thus,
640 * the process of taking that image to the CPU would end up
c3af1715 641 * little endian. However, the firmware interface requires it
1da177e4
LT		 642 * to be read a word (two bytes) at a time.
643 *
644 * The net result of this would be that the word (and
645 * doubleword) quantites in the firmware would be correct, but
646 * the bytes would be pairwise reversed. Since most of the
647 * firmware quantites are, in fact, bytes, we do an extra
648 * le16_to_cpu() in the firmware read routine.
649 *
650 * The upshot of all this is that the bytes in the firmware
651 * are in the correct places, but the 16 and 32 bit quantites
652 * are still in little endian format. We fix that up below by
653 * doing extra reverses on them */
654 nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
655 nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
656 for(i = 0; i < MAX_BUSES; i++) {
657 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
658 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
659 }
660 dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
661 LEAVE("qla1280_read_nvram");
662
663 return chksum;
664}
665
666/**************************************************************************
667 * qla1280_info
668 * Return a string describing the driver.
669 **************************************************************************/
670static const char *
671qla1280_info(struct Scsi_Host *host)
672{
673 static char qla1280_scsi_name_buffer[125];
674 char *bp;
675 struct scsi_qla_host *ha;
676 struct qla_boards *bdp;
677
678 bp = &qla1280_scsi_name_buffer[0];
679 ha = (struct scsi_qla_host *)host->hostdata;
680 bdp = &ql1280_board_tbl[ha->devnum];
681 memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
682
683 sprintf (bp,
684 "QLogic %s PCI to SCSI Host Adapter\n"
685 " Firmware version: %2d.%02d.%02d, Driver version %s",
1bfa11db 686 &bdp->name[0], ha->fwver1, ha->fwver2, ha->fwver3,
1da177e4
LT		 687 QLA1280_VERSION);
688 return bp;
689}
690
691/**************************************************************************
fd65e5e9 692 * qla1280_queuecommand
1da177e4
LT		 693 * Queue a command to the controller.
694 *
695 * Note:
696 * The mid-level driver tries to ensures that queuecommand never gets invoked
697 * concurrently with itself or the interrupt handler (although the
698 * interrupt handler may call this routine as part of request-completion
699 * handling). Unfortunely, it sometimes calls the scheduler in interrupt
700 * context which is a big NO! NO!.
701 **************************************************************************/
702static int
f281233d 703qla1280_queuecommand_lck(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
1da177e4
LT		 704{
705 struct Scsi_Host *host = cmd->device->host;
706 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
fd65e5e9 707 struct srb *sp = (struct srb *)CMD_SP(cmd);
1da177e4
LT		 708 int status;
709
710 cmd->scsi_done = fn;
711 sp->cmd = cmd;
712 sp->flags = 0;
413e6e18
MR		 713 sp->wait = NULL;
714 CMD_HANDLE(cmd) = (unsigned char *)NULL;
1da177e4
LT		 715
716 qla1280_print_scsi_cmd(5, cmd);
717
718#ifdef QLA_64BIT_PTR
719 /*
720 * Using 64 bit commands if the PCI bridge doesn't support it is a
721 * bit wasteful, however this should really only happen if one's
722 * PCI controller is completely broken, like the BCM1250. For
723 * sane hardware this is not an issue.
724 */
725 status = qla1280_64bit_start_scsi(ha, sp);
726#else
727 status = qla1280_32bit_start_scsi(ha, sp);
728#endif
729 return status;
730}
731
f281233d
JG		 732static DEF_SCSI_QCMD(qla1280_queuecommand)
733
1da177e4
LT		 734enum action {
735 ABORT_COMMAND,
1da177e4
LT		 736 DEVICE_RESET,
737 BUS_RESET,
738 ADAPTER_RESET,
1da177e4
LT		 739};
740
1da177e4 741
9c6c273a 742static void qla1280_mailbox_timeout(struct timer_list *t)
1da177e4 743{
9c6c273a 744 struct scsi_qla_host *ha = from_timer(ha, t, mailbox_timer);
1da177e4
LT		 745 struct device_reg __iomem *reg;
746 reg = ha->iobase;
747
748 ha->mailbox_out[0] = RD_REG_WORD(&reg->mailbox0);
749 printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
750 "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
751 RD_REG_WORD(&reg->ictrl), RD_REG_WORD(&reg->istatus));
752 complete(ha->mailbox_wait);
753}
754
413e6e18
MR		 755static int
756_qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp,
757 struct completion *wait)
758{
759 int status = FAILED;
760 struct scsi_cmnd *cmd = sp->cmd;
761
762 spin_unlock_irq(ha->host->host_lock);
763 wait_for_completion_timeout(wait, 4*HZ);
764 spin_lock_irq(ha->host->host_lock);
765 sp->wait = NULL;
766 if(CMD_HANDLE(cmd) == COMPLETED_HANDLE) {
767 status = SUCCESS;
768 (*cmd->scsi_done)(cmd);
769 }
770 return status;
771}
772
773static int
774qla1280_wait_for_single_command(struct scsi_qla_host *ha, struct srb *sp)
775{
776 DECLARE_COMPLETION_ONSTACK(wait);
777
778 sp->wait = &wait;
779 return _qla1280_wait_for_single_command(ha, sp, &wait);
780}
781
782static int
783qla1280_wait_for_pending_commands(struct scsi_qla_host *ha, int bus, int target)
784{
785 int cnt;
786 int status;
787 struct srb *sp;
788 struct scsi_cmnd *cmd;
789
790 status = SUCCESS;
791
792 /*
793 * Wait for all commands with the designated bus/target
794 * to be completed by the firmware
795 */
796 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
797 sp = ha->outstanding_cmds[cnt];
798 if (sp) {
799 cmd = sp->cmd;
800
801 if (bus >= 0 && SCSI_BUS_32(cmd) != bus)
802 continue;
803 if (target >= 0 && SCSI_TCN_32(cmd) != target)
804 continue;
805
806 status = qla1280_wait_for_single_command(ha, sp);
807 if (status == FAILED)
808 break;
809 }
810 }
811 return status;
812}
813
1da177e4 814/**************************************************************************
fd65e5e9 815 * qla1280_error_action
1da177e4
LT		 816 * The function will attempt to perform a specified error action and
817 * wait for the results (or time out).
818 *
819 * Input:
820 * cmd = Linux SCSI command packet of the command that cause the
821 * bus reset.
822 * action = error action to take (see action_t)
823 *
824 * Returns:
825 * SUCCESS or FAILED
826 *
1da177e4
LT		 827 **************************************************************************/
828static int
829qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
830{
831 struct scsi_qla_host *ha;
832 int bus, target, lun;
833 struct srb *sp;
413e6e18
MR		 834 int i, found;
835 int result=FAILED;
836 int wait_for_bus=-1;
837 int wait_for_target = -1;
6e9a4738 838 DECLARE_COMPLETION_ONSTACK(wait);
1da177e4 839
fd65e5e9
MR		 840 ENTER("qla1280_error_action");
841
1da177e4 842 ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
413e6e18
MR		 843 sp = (struct srb *)CMD_SP(cmd);
844 bus = SCSI_BUS_32(cmd);
845 target = SCSI_TCN_32(cmd);
846 lun = SCSI_LUN_32(cmd);
1da177e4
LT		 847
848 dprintk(4, "error_action %i, istatus 0x%04x\n", action,
849 RD_REG_WORD(&ha->iobase->istatus));
850
851 dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
852 RD_REG_WORD(&ha->iobase->host_cmd),
853 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
854
1da177e4
LT		 855 if (qla1280_verbose)
856 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
857 "Handle=0x%p, action=0x%x\n",
858 ha->host_no, cmd, CMD_HANDLE(cmd), action);
859
1da177e4 860 /*
413e6e18
MR		 861 * Check to see if we have the command in the outstanding_cmds[]
862 * array. If not then it must have completed before this error
863 * action was initiated. If the error_action isn't ABORT_COMMAND
864 * then the driver must proceed with the requested action.
1da177e4 865 */
413e6e18
MR		 866 found = -1;
867 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
868 if (sp == ha->outstanding_cmds[i]) {
869 found = i;
870 sp->wait = &wait; /* we'll wait for it to complete */
871 break;
1da177e4 872 }
1da177e4
LT		 873 }
874
413e6e18
MR		 875 if (found < 0) { /* driver doesn't have command */
876 result = SUCCESS;
877 if (qla1280_verbose) {
878 printk(KERN_INFO
879 "scsi(%ld:%d:%d:%d): specified command has "
880 "already completed.\n", ha->host_no, bus,
881 target, lun);
882 }
883 }
1da177e4 884
1da177e4 885 switch (action) {
1da177e4 886
413e6e18
MR		 887 case ABORT_COMMAND:
888 dprintk(1, "qla1280: RISC aborting command\n");
889 /*
890 * The abort might fail due to race when the host_lock
891 * is released to issue the abort. As such, we
892 * don't bother to check the return status.
893 */
894 if (found >= 0)
895 qla1280_abort_command(ha, sp, found);
1da177e4
LT		 896 break;
897
1da177e4
LT		 898 case DEVICE_RESET:
899 if (qla1280_verbose)
900 printk(KERN_INFO
901 "scsi(%ld:%d:%d:%d): Queueing device reset "
902 "command.\n", ha->host_no, bus, target, lun);
413e6e18
MR		 903 if (qla1280_device_reset(ha, bus, target) == 0) {
904 /* issued device reset, set wait conditions */
905 wait_for_bus = bus;
906 wait_for_target = target;
907 }
1da177e4
LT		 908 break;
909
910 case BUS_RESET:
911 if (qla1280_verbose)
cd00b7f5
JS		 912 printk(KERN_INFO "qla1280(%ld:%d): Issued bus "
913 "reset.\n", ha->host_no, bus);
413e6e18
MR		 914 if (qla1280_bus_reset(ha, bus) == 0) {
915 /* issued bus reset, set wait conditions */
916 wait_for_bus = bus;
917 }
1da177e4
LT		 918 break;
919
920 case ADAPTER_RESET:
921 default:
922 if (qla1280_verbose) {
923 printk(KERN_INFO
924 "scsi(%ld): Issued ADAPTER RESET\n",
925 ha->host_no);
926 printk(KERN_INFO "scsi(%ld): I/O processing will "
927 "continue automatically\n", ha->host_no);
928 }
929 ha->flags.reset_active = 1;
413e6e18
MR		 930
931 if (qla1280_abort_isp(ha) != 0) { /* it's dead */
932 result = FAILED;
933 }
1da177e4
LT		 934
935 ha->flags.reset_active = 0;
936 }
937
413e6e18
MR		 938 /*
939 * At this point, the host_lock has been released and retaken
940 * by the issuance of the mailbox command.
941 * Wait for the command passed in by the mid-layer if it
942 * was found by the driver. It might have been returned
943 * between eh recovery steps, hence the check of the "found"
944 * variable.
945 */
1da177e4 946
413e6e18
MR		 947 if (found >= 0)
948 result = _qla1280_wait_for_single_command(ha, sp, &wait);
1da177e4 949
413e6e18
MR		 950 if (action == ABORT_COMMAND && result != SUCCESS) {
951 printk(KERN_WARNING
952 "scsi(%li:%i:%i:%i): "
953 "Unable to abort command!\n",
954 ha->host_no, bus, target, lun);
955 }
1da177e4 956
413e6e18
MR		 957 /*
958 * If the command passed in by the mid-layer has been
959 * returned by the board, then wait for any additional
960 * commands which are supposed to complete based upon
961 * the error action.
962 *
963 * All commands are unconditionally returned during a
964 * call to qla1280_abort_isp(), ADAPTER_RESET. No need
965 * to wait for them.
966 */
967 if (result == SUCCESS && wait_for_bus >= 0) {
968 result = qla1280_wait_for_pending_commands(ha,
969 wait_for_bus, wait_for_target);
1da177e4
LT		 970 }
971
1da177e4
LT		 972 dprintk(1, "RESET returning %d\n", result);
973
974 LEAVE("qla1280_error_action");
975 return result;
976}
977
978/**************************************************************************
979 * qla1280_abort
980 * Abort the specified SCSI command(s).
981 **************************************************************************/
982static int
983qla1280_eh_abort(struct scsi_cmnd * cmd)
984{
8fa728a2
JG		 985 int rc;
986
987 spin_lock_irq(cmd->device->host->host_lock);
988 rc = qla1280_error_action(cmd, ABORT_COMMAND);
989 spin_unlock_irq(cmd->device->host->host_lock);
990
991 return rc;
1da177e4
LT		 992}
993
994/**************************************************************************
995 * qla1280_device_reset
996 * Reset the specified SCSI device
997 **************************************************************************/
998static int
999qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1000{
94d0e7b8
JG		 1001 int rc;
1002
1003 spin_lock_irq(cmd->device->host->host_lock);
1004 rc = qla1280_error_action(cmd, DEVICE_RESET);
1005 spin_unlock_irq(cmd->device->host->host_lock);
1006
1007 return rc;
1da177e4
LT		 1008}
1009
1010/**************************************************************************
1011 * qla1280_bus_reset
1012 * Reset the specified bus.
1013 **************************************************************************/
1014static int
1015qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1016{
68b3aa7c
JG		 1017 int rc;
1018
1019 spin_lock_irq(cmd->device->host->host_lock);
1020 rc = qla1280_error_action(cmd, BUS_RESET);
1021 spin_unlock_irq(cmd->device->host->host_lock);
1022
1023 return rc;
1da177e4
LT		 1024}
1025
1026/**************************************************************************
1027 * qla1280_adapter_reset
1028 * Reset the specified adapter (both channels)
1029 **************************************************************************/
1030static int
1031qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1032{
df0ae249
JG		 1033 int rc;
1034
1035 spin_lock_irq(cmd->device->host->host_lock);
1036 rc = qla1280_error_action(cmd, ADAPTER_RESET);
1037 spin_unlock_irq(cmd->device->host->host_lock);
1038
1039 return rc;
1da177e4
LT		 1040}
1041
1042static int
1043qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1044 sector_t capacity, int geom[])
1045{
1046 int heads, sectors, cylinders;
1047
1048 heads = 64;
1049 sectors = 32;
1050 cylinders = (unsigned long)capacity / (heads * sectors);
1051 if (cylinders > 1024) {
1052 heads = 255;
1053 sectors = 63;
1054 cylinders = (unsigned long)capacity / (heads * sectors);
1055 /* if (cylinders > 1023)
1056 cylinders = 1023; */
1057 }
1058
1059 geom[0] = heads;
1060 geom[1] = sectors;
1061 geom[2] = cylinders;
1062
1063 return 0;
1064}
1065
8af50dcd
CH		 1066
1067/* disable risc and host interrupts */
1068static inline void
1069qla1280_disable_intrs(struct scsi_qla_host *ha)
1070{
1071 WRT_REG_WORD(&ha->iobase->ictrl, 0);
1072 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1073}
1074
1075/* enable risc and host interrupts */
1076static inline void
1077qla1280_enable_intrs(struct scsi_qla_host *ha)
1078{
1079 WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1080 RD_REG_WORD(&ha->iobase->ictrl); /* PCI Posted Write flush */
1081}
1da177e4
LT		 1082
1083/**************************************************************************
1084 * qla1280_intr_handler
1085 * Handles the H/W interrupt
1086 **************************************************************************/
1087static irqreturn_t
7d12e780 1088qla1280_intr_handler(int irq, void *dev_id)
1da177e4
LT		 1089{
1090 struct scsi_qla_host *ha;
1091 struct device_reg __iomem *reg;
1092 u16 data;
1093 int handled = 0;
1094
1095 ENTER_INTR ("qla1280_intr_handler");
1096 ha = (struct scsi_qla_host *)dev_id;
1097
2dbb04c6 1098 spin_lock(ha->host->host_lock);
1da177e4
LT		 1099
1100 ha->isr_count++;
1101 reg = ha->iobase;
1102
8af50dcd 1103 qla1280_disable_intrs(ha);
1da177e4
LT		 1104
1105 data = qla1280_debounce_register(&reg->istatus);
1106 /* Check for pending interrupts. */
1107 if (data & RISC_INT) {
1108 qla1280_isr(ha, &ha->done_q);
1109 handled = 1;
1110 }
1111 if (!list_empty(&ha->done_q))
1112 qla1280_done(ha);
1113
2dbb04c6 1114 spin_unlock(ha->host->host_lock);
1da177e4 1115
8af50dcd 1116 qla1280_enable_intrs(ha);
1da177e4
LT		 1117
1118 LEAVE_INTR("qla1280_intr_handler");
1119 return IRQ_RETVAL(handled);
1120}
1121
1122
1123static int
1124qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1125{
1126 uint8_t mr;
1127 uint16_t mb[MAILBOX_REGISTER_COUNT];
1128 struct nvram *nv;
7a34766f 1129 int status, lun;
1da177e4
LT		 1130
1131 nv = &ha->nvram;
1132
1133 mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1134
1135 /* Set Target Parameters. */
1136 mb[0] = MBC_SET_TARGET_PARAMETERS;
7a34766f
CH		 1137 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1138 mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1139 mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1140 mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1141 mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1142 mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1143 mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1144 mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1145 mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1da177e4
LT		 1146
1147 if (IS_ISP1x160(ha)) {
1148 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
7a34766f 1149 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1da177e4
LT		 1150 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1151 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1152 mr |= BIT_6;
1153 } else {
7a34766f 1154 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1da177e4 1155 }
7a34766f
CH		 1156 mb[3] |= nv->bus[bus].target[target].sync_period;
1157
1158 status = qla1280_mailbox_command(ha, mr, mb);
1da177e4 1159
7a34766f
CH		 1160 /* Set Device Queue Parameters. */
1161 for (lun = 0; lun < MAX_LUNS; lun++) {
1162 mb[0] = MBC_SET_DEVICE_QUEUE;
1163 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1164 mb[1] |= lun;
1165 mb[2] = nv->bus[bus].max_queue_depth;
1166 mb[3] = nv->bus[bus].target[target].execution_throttle;
1167 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1168 }
1da177e4
LT		 1169
1170 if (status)
1171 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1172 "qla1280_set_target_parameters() failed\n",
1173 ha->host_no, bus, target);
1174 return status;
1175}
1176
1177
1178/**************************************************************************
1179 * qla1280_slave_configure
1180 *
1181 * Description:
1182 * Determines the queue depth for a given device. There are two ways
1183 * a queue depth can be obtained for a tagged queueing device. One
1184 * way is the default queue depth which is determined by whether
1185 * If it is defined, then it is used
1186 * as the default queue depth. Otherwise, we use either 4 or 8 as the
1187 * default queue depth (dependent on the number of hardware SCBs).
1188 **************************************************************************/
1189static int
1190qla1280_slave_configure(struct scsi_device *device)
1191{
1192 struct scsi_qla_host *ha;
1193 int default_depth = 3;
1194 int bus = device->channel;
1195 int target = device->id;
1196 int status = 0;
1197 struct nvram *nv;
1198 unsigned long flags;
1199
1200 ha = (struct scsi_qla_host *)device->host->hostdata;
1201 nv = &ha->nvram;
1202
1203 if (qla1280_check_for_dead_scsi_bus(ha, bus))
1204 return 1;
1205
1206 if (device->tagged_supported &&
1207 (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
db5ed4df 1208 scsi_change_queue_depth(device, ha->bus_settings[bus].hiwat);
1da177e4 1209 } else {
db5ed4df 1210 scsi_change_queue_depth(device, default_depth);
1da177e4
LT		 1211 }
1212
7a34766f
CH		 1213 nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1214 nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1da177e4 1215 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1da177e4
LT		 1216
1217 if (driver_setup.no_sync ||
1218 (driver_setup.sync_mask &&
1219 (~driver_setup.sync_mask & (1 << target))))
7a34766f 1220 nv->bus[bus].target[target].parameter.enable_sync = 0;
1da177e4
LT		 1221 if (driver_setup.no_wide ||
1222 (driver_setup.wide_mask &&
1223 (~driver_setup.wide_mask & (1 << target))))
7a34766f 1224 nv->bus[bus].target[target].parameter.enable_wide = 0;
1da177e4
LT		 1225 if (IS_ISP1x160(ha)) {
1226 if (driver_setup.no_ppr ||
1227 (driver_setup.ppr_mask &&
1228 (~driver_setup.ppr_mask & (1 << target))))
1229 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1230 }
1231
2dbb04c6 1232 spin_lock_irqsave(ha->host->host_lock, flags);
7a34766f 1233 if (nv->bus[bus].target[target].parameter.enable_sync)
1da177e4
LT		 1234 status = qla1280_set_target_parameters(ha, bus, target);
1235 qla1280_get_target_parameters(ha, device);
2dbb04c6 1236 spin_unlock_irqrestore(ha->host->host_lock, flags);
1da177e4
LT		 1237 return status;
1238}
1239
1da177e4
LT		 1240
1241/*
1242 * qla1280_done
1243 * Process completed commands.
1244 *
1245 * Input:
1246 * ha = adapter block pointer.
1da177e4
LT		 1247 */
1248static void
1249qla1280_done(struct scsi_qla_host *ha)
1250{
1251 struct srb *sp;
1252 struct list_head *done_q;
1253 int bus, target, lun;
1254 struct scsi_cmnd *cmd;
1255
1256 ENTER("qla1280_done");
1257
1258 done_q = &ha->done_q;
1259
1260 while (!list_empty(done_q)) {
1261 sp = list_entry(done_q->next, struct srb, list);
1262
1263 list_del(&sp->list);
1264
1265 cmd = sp->cmd;
1266 bus = SCSI_BUS_32(cmd);
1267 target = SCSI_TCN_32(cmd);
1268 lun = SCSI_LUN_32(cmd);
1269
1270 switch ((CMD_RESULT(cmd) >> 16)) {
1271 case DID_RESET:
1272 /* Issue marker command. */
413e6e18
MR		 1273 if (!ha->flags.abort_isp_active)
1274 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1da177e4
LT		 1275 break;
1276 case DID_ABORT:
1277 sp->flags &= ~SRB_ABORT_PENDING;
1278 sp->flags |= SRB_ABORTED;
1da177e4
LT		 1279 break;
1280 default:
1281 break;
1282 }
1283
1284 /* Release memory used for this I/O */
5c1da582 1285 scsi_dma_unmap(cmd);
1da177e4
LT		 1286
1287 /* Call the mid-level driver interrupt handler */
1da177e4
LT		 1288 ha->actthreads--;
1289
413e6e18
MR		 1290 if (sp->wait == NULL)
1291 (*(cmd)->scsi_done)(cmd);
1292 else
1da177e4
LT		 1293 complete(sp->wait);
1294 }
1295 LEAVE("qla1280_done");
1296}
1297
1298/*
1299 * Translates a ISP error to a Linux SCSI error
1300 */
1301static int
1302qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1303{
1304 int host_status = DID_ERROR;
1305 uint16_t comp_status = le16_to_cpu(sts->comp_status);
1306 uint16_t state_flags = le16_to_cpu(sts->state_flags);
3ef49a3b 1307 uint32_t residual_length = le32_to_cpu(sts->residual_length);
1da177e4
LT		 1308 uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1309#if DEBUG_QLA1280_INTR
1310 static char *reason[] = {
1311 "DID_OK",
1312 "DID_NO_CONNECT",
1313 "DID_BUS_BUSY",
1314 "DID_TIME_OUT",
1315 "DID_BAD_TARGET",
1316 "DID_ABORT",
1317 "DID_PARITY",
1318 "DID_ERROR",
1319 "DID_RESET",
1320 "DID_BAD_INTR"
1321 };
1322#endif /* DEBUG_QLA1280_INTR */
1323
1324 ENTER("qla1280_return_status");
1325
1326#if DEBUG_QLA1280_INTR
1327 /*
1328 dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1329 comp_status);
1330 */
1331#endif
1332
1333 switch (comp_status) {
1334 case CS_COMPLETE:
1335 host_status = DID_OK;
1336 break;
1337
1338 case CS_INCOMPLETE:
1339 if (!(state_flags & SF_GOT_BUS))
1340 host_status = DID_NO_CONNECT;
1341 else if (!(state_flags & SF_GOT_TARGET))
1342 host_status = DID_BAD_TARGET;
1343 else if (!(state_flags & SF_SENT_CDB))
1344 host_status = DID_ERROR;
1345 else if (!(state_flags & SF_TRANSFERRED_DATA))
1346 host_status = DID_ERROR;
1347 else if (!(state_flags & SF_GOT_STATUS))
1348 host_status = DID_ERROR;
1349 else if (!(state_flags & SF_GOT_SENSE))
1350 host_status = DID_ERROR;
1351 break;
1352
1353 case CS_RESET:
1354 host_status = DID_RESET;
1355 break;
1356
1357 case CS_ABORTED:
1358 host_status = DID_ABORT;
1359 break;
1360
1361 case CS_TIMEOUT:
1362 host_status = DID_TIME_OUT;
1363 break;
1364
1365 case CS_DATA_OVERRUN:
1366 dprintk(2, "Data overrun 0x%x\n", residual_length);
2b55cac3 1367 dprintk(2, "qla1280_return_status: response packet data\n");
1da177e4
LT		 1368 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1369 host_status = DID_ERROR;
1370 break;
1371
1372 case CS_DATA_UNDERRUN:
5c1da582 1373 if ((scsi_bufflen(cp) - residual_length) <
1da177e4
LT		 1374 cp->underflow) {
1375 printk(KERN_WARNING
1376 "scsi: Underflow detected - retrying "
1377 "command.\n");
1378 host_status = DID_ERROR;
3ef49a3b 1379 } else {
5c1da582 1380 scsi_set_resid(cp, residual_length);
1da177e4 1381 host_status = DID_OK;
3ef49a3b 1382 }
1da177e4
LT		 1383 break;
1384
1385 default:
1386 host_status = DID_ERROR;
1387 break;
1388 }
1389
1390#if DEBUG_QLA1280_INTR
1391 dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1392 reason[host_status], scsi_status);
1393#endif
1394
1395 LEAVE("qla1280_return_status");
1396
1397 return (scsi_status & 0xff) | (host_status << 16);
1398}
1399
1400/****************************************************************************/
1401/* QLogic ISP1280 Hardware Support Functions. */
1402/****************************************************************************/
1403
1da177e4
LT		 1404/*
1405 * qla1280_initialize_adapter
1406 * Initialize board.
1407 *
1408 * Input:
1409 * ha = adapter block pointer.
1410 *
1411 * Returns:
1412 * 0 = success
1413 */
6f039790 1414static int
1da177e4
LT		 1415qla1280_initialize_adapter(struct scsi_qla_host *ha)
1416{
1417 struct device_reg __iomem *reg;
1418 int status;
1419 int bus;
1da177e4 1420 unsigned long flags;
1da177e4
LT		 1421
1422 ENTER("qla1280_initialize_adapter");
1423
1424 /* Clear adapter flags. */
1425 ha->flags.online = 0;
1426 ha->flags.disable_host_adapter = 0;
1427 ha->flags.reset_active = 0;
1428 ha->flags.abort_isp_active = 0;
1429
1da177e4
LT		 1430#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1431 if (ia64_platform_is("sn2")) {
1432 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
1433 "dual channel lockup workaround\n", ha->host_no);
1434 ha->flags.use_pci_vchannel = 1;
1435 driver_setup.no_nvram = 1;
1436 }
1437#endif
1438
1439 /* TODO: implement support for the 1040 nvram format */
1440 if (IS_ISP1040(ha))
1441 driver_setup.no_nvram = 1;
1442
1443 dprintk(1, "Configure PCI space for adapter...\n");
1444
1445 reg = ha->iobase;
1446
1447 /* Insure mailbox registers are free. */
1448 WRT_REG_WORD(&reg->semaphore, 0);
1449 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
1450 WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
1451 RD_REG_WORD(&reg->host_cmd);
1452
1453 if (qla1280_read_nvram(ha)) {
1454 dprintk(2, "qla1280_initialize_adapter: failed to read "
1455 "NVRAM\n");
1456 }
1457
1da177e4
LT		 1458 /*
1459 * It's necessary to grab the spin here as qla1280_mailbox_command
1460 * needs to be able to drop the lock unconditionally to wait
1461 * for completion.
1da177e4 1462 */
2dbb04c6 1463 spin_lock_irqsave(ha->host->host_lock, flags);
1da177e4
LT		 1464
1465 status = qla1280_load_firmware(ha);
1466 if (status) {
1467 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1468 ha->host_no);
1469 goto out;
1470 }
1471
1472 /* Setup adapter based on NVRAM parameters. */
1473 dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1474 qla1280_nvram_config(ha);
1475
1476 if (ha->flags.disable_host_adapter) {
1477 status = 1;
1478 goto out;
1479 }
1480
1481 status = qla1280_init_rings(ha);
1482 if (status)
1483 goto out;
1484
1485 /* Issue SCSI reset, if we can't reset twice then bus is dead */
1486 for (bus = 0; bus < ha->ports; bus++) {
1487 if (!ha->bus_settings[bus].disable_scsi_reset &&
1488 qla1280_bus_reset(ha, bus) &&
1489 qla1280_bus_reset(ha, bus))
1490 ha->bus_settings[bus].scsi_bus_dead = 1;
1491 }
1492
1493 ha->flags.online = 1;
1494 out:
2dbb04c6
JS		 1495 spin_unlock_irqrestore(ha->host->host_lock, flags);
1496
1da177e4
LT		 1497 if (status)
1498 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1499
1500 LEAVE("qla1280_initialize_adapter");
1501 return status;
1502}
1503
421e33d0
MR		 1504/*
1505 * qla1280_request_firmware
1506 * Acquire firmware for chip. Retain in memory
1507 * for error recovery.
1508 *
1509 * Input:
1510 * ha = adapter block pointer.
1511 *
1512 * Returns:
1513 * Pointer to firmware image or an error code
1514 * cast to pointer via ERR_PTR().
1515 */
1516static const struct firmware *
1517qla1280_request_firmware(struct scsi_qla_host *ha)
1518{
1519 const struct firmware *fw;
1520 int err;
1521 int index;
1522 char *fwname;
1523
1524 spin_unlock_irq(ha->host->host_lock);
1525 mutex_lock(&qla1280_firmware_mutex);
1526
1527 index = ql1280_board_tbl[ha->devnum].fw_index;
1528 fw = qla1280_fw_tbl[index].fw;
1529 if (fw)
1530 goto out;
1531
1532 fwname = qla1280_fw_tbl[index].fwname;
1533 err = request_firmware(&fw, fwname, &ha->pdev->dev);
1534
1535 if (err) {
1536 printk(KERN_ERR "Failed to load image \"%s\" err %d\n",
1537 fwname, err);
1538 fw = ERR_PTR(err);
1539 goto unlock;
1540 }
1541 if ((fw->size % 2) || (fw->size < 6)) {
1542 printk(KERN_ERR "Invalid firmware length %zu in image \"%s\"\n",
1543 fw->size, fwname);
1544 release_firmware(fw);
1545 fw = ERR_PTR(-EINVAL);
1546 goto unlock;
1547 }
1548
1549 qla1280_fw_tbl[index].fw = fw;
1550
1551 out:
1552 ha->fwver1 = fw->data[0];
1553 ha->fwver2 = fw->data[1];
1554 ha->fwver3 = fw->data[2];
1555 unlock:
1556 mutex_unlock(&qla1280_firmware_mutex);
1557 spin_lock_irq(ha->host->host_lock);
1558 return fw;
1559}
1560
1da177e4
LT		 1561/*
1562 * Chip diagnostics
1563 * Test chip for proper operation.
1564 *
1565 * Input:
1566 * ha = adapter block pointer.
1567 *
1568 * Returns:
1569 * 0 = success.
1570 */
1571static int
1572qla1280_chip_diag(struct scsi_qla_host *ha)
1573{
1574 uint16_t mb[MAILBOX_REGISTER_COUNT];
1575 struct device_reg __iomem *reg = ha->iobase;
1576 int status = 0;
1577 int cnt;
1578 uint16_t data;
1579 dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", &reg->id_l);
1580
1581 dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1582
1583 /* Soft reset chip and wait for it to finish. */
1584 WRT_REG_WORD(&reg->ictrl, ISP_RESET);
1585
1586 /*
1587 * We can't do a traditional PCI write flush here by reading
1588 * back the register. The card will not respond once the reset
1589 * is in action and we end up with a machine check exception
1590 * instead. Nothing to do but wait and hope for the best.
1591 * A portable pci_write_flush(pdev) call would be very useful here.
1592 */
1593 udelay(20);
1594 data = qla1280_debounce_register(&reg->ictrl);
1595 /*
1596 * Yet another QLogic gem ;-(
1597 */
1598 for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1599 udelay(5);
1600 data = RD_REG_WORD(&reg->ictrl);
1601 }
1602
1603 if (!cnt)
1604 goto fail;
1605
1606 /* Reset register cleared by chip reset. */
1607 dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1608
1609 WRT_REG_WORD(&reg->cfg_1, 0);
1610
1611 /* Reset RISC and disable BIOS which
1612 allows RISC to execute out of RAM. */
1613 WRT_REG_WORD(&reg->host_cmd, HC_RESET_RISC |
1614 HC_RELEASE_RISC | HC_DISABLE_BIOS);
1615
1616 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
1617 data = qla1280_debounce_register(&reg->mailbox0);
1618
1619 /*
1620 * I *LOVE* this code!
1621 */
1622 for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1623 udelay(5);
1624 data = RD_REG_WORD(&reg->mailbox0);
1625 }
1626
1627 if (!cnt)
1628 goto fail;
1629
1630 /* Check product ID of chip */
1631 dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1632
1633 if (RD_REG_WORD(&reg->mailbox1) != PROD_ID_1 ||
1634 (RD_REG_WORD(&reg->mailbox2) != PROD_ID_2 &&
1635 RD_REG_WORD(&reg->mailbox2) != PROD_ID_2a) ||
1636 RD_REG_WORD(&reg->mailbox3) != PROD_ID_3 ||
1637 RD_REG_WORD(&reg->mailbox4) != PROD_ID_4) {
1638 printk(KERN_INFO "qla1280: Wrong product ID = "
1639 "0x%x,0x%x,0x%x,0x%x\n",
1640 RD_REG_WORD(&reg->mailbox1),
1641 RD_REG_WORD(&reg->mailbox2),
1642 RD_REG_WORD(&reg->mailbox3),
1643 RD_REG_WORD(&reg->mailbox4));
1644 goto fail;
1645 }
1646
1647 /*
1648 * Enable ints early!!!
1649 */
1650 qla1280_enable_intrs(ha);
1651
1652 dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1653 /* Wrap Incoming Mailboxes Test. */
1654 mb[0] = MBC_MAILBOX_REGISTER_TEST;
1655 mb[1] = 0xAAAA;
1656 mb[2] = 0x5555;
1657 mb[3] = 0xAA55;
1658 mb[4] = 0x55AA;
1659 mb[5] = 0xA5A5;
1660 mb[6] = 0x5A5A;
1661 mb[7] = 0x2525;
1662
1663 status = qla1280_mailbox_command(ha, 0xff, mb);
1664 if (status)
1665 goto fail;
1666
1667 if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1668 mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1669 mb[7] != 0x2525) {
1670 printk(KERN_INFO "qla1280: Failed mbox check\n");
1671 goto fail;
1672 }
1673
1674 dprintk(3, "qla1280_chip_diag: exiting normally\n");
1675 return 0;
1676 fail:
1677 dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1678 return status;
1679}
1680
1681static int
1682qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1683{
421e33d0
MR		 1684 /* enter with host_lock acquired */
1685
1bfa11db
JSR		 1686 const struct firmware *fw;
1687 const __le16 *fw_data;
1688 uint16_t risc_address, risc_code_size;
1da177e4 1689 uint16_t mb[MAILBOX_REGISTER_COUNT], i;
421e33d0
MR		 1690 int err = 0;
1691
1692 fw = qla1280_request_firmware(ha);
1693 if (IS_ERR(fw))
1694 return PTR_ERR(fw);
1da177e4 1695
1bfa11db
JSR		 1696 fw_data = (const __le16 *)&fw->data[0];
1697 ha->fwstart = __le16_to_cpu(fw_data[2]);
1698
1da177e4 1699 /* Load RISC code. */
1bfa11db 1700 risc_address = ha->fwstart;
0ce49d6d 1701 fw_data = (const __le16 *)&fw->data[6];
1bfa11db 1702 risc_code_size = (fw->size - 6) / 2;
1da177e4
LT		 1703
1704 for (i = 0; i < risc_code_size; i++) {
1705 mb[0] = MBC_WRITE_RAM_WORD;
1706 mb[1] = risc_address + i;
1bfa11db 1707 mb[2] = __le16_to_cpu(fw_data[i]);
1da177e4
LT		 1708
1709 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1710 if (err) {
1711 printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1712 ha->host_no);
421e33d0 1713 break;
1da177e4
LT		 1714 }
1715 }
421e33d0 1716
1bfa11db 1717 return err;
1da177e4
LT		 1718}
1719
1720#define DUMP_IT_BACK 0 /* for debug of RISC loading */
1721static int
1722qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1723{
421e33d0 1724 /* enter with host_lock acquired */
1bfa11db
JSR		 1725 const struct firmware *fw;
1726 const __le16 *fw_data;
1727 uint16_t risc_address, risc_code_size;
1da177e4
LT		 1728 uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1729 int err = 0, num, i;
1730#if DUMP_IT_BACK
1731 uint8_t *sp, *tbuf;
1732 dma_addr_t p_tbuf;
1733
60ea4fb1 1734 tbuf = dma_alloc_coherent(&ha->pdev->dev, 8000, &p_tbuf, GFP_KERNEL);
1da177e4
LT		 1735 if (!tbuf)
1736 return -ENOMEM;
1737#endif
1738
421e33d0
MR		 1739 fw = qla1280_request_firmware(ha);
1740 if (IS_ERR(fw))
1741 return PTR_ERR(fw);
1742
1bfa11db
JSR		 1743 fw_data = (const __le16 *)&fw->data[0];
1744 ha->fwstart = __le16_to_cpu(fw_data[2]);
1745
1da177e4 1746 /* Load RISC code. */
1bfa11db 1747 risc_address = ha->fwstart;
0ce49d6d 1748 fw_data = (const __le16 *)&fw->data[6];
1bfa11db 1749 risc_code_size = (fw->size - 6) / 2;
1da177e4
LT		 1750
1751 dprintk(1, "%s: DMA RISC code (%i) words\n",
cadbd4a5 1752 __func__, risc_code_size);
1da177e4
LT		 1753
1754 num = 0;
1755 while (risc_code_size > 0) {
1756 int warn __attribute__((unused)) = 0;
1757
1758 cnt = 2000 >> 1;
1759
1760 if (cnt > risc_code_size)
1761 cnt = risc_code_size;
1762
1763 dprintk(2, "qla1280_setup_chip: loading risc @ =(0x%p),"
1764 "%d,%d(0x%x)\n",
1bfa11db 1765 fw_data, cnt, num, risc_address);
1da177e4 1766 for(i = 0; i < cnt; i++)
1bfa11db 1767 ((__le16 *)ha->request_ring)[i] = fw_data[i];
1da177e4
LT		 1768
1769 mb[0] = MBC_LOAD_RAM;
1770 mb[1] = risc_address;
1771 mb[4] = cnt;
1772 mb[3] = ha->request_dma & 0xffff;
1773 mb[2] = (ha->request_dma >> 16) & 0xffff;
f20f43c3
CH		 1774 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1775 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1da177e4 1776 dprintk(2, "%s: op=%d 0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
cadbd4a5 1777 __func__, mb[0],
1da177e4
LT		 1778 (void *)(long)ha->request_dma,
1779 mb[6], mb[7], mb[2], mb[3]);
1780 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1781 BIT_1 | BIT_0, mb);
1782 if (err) {
1783 printk(KERN_ERR "scsi(%li): Failed to load partial "
1784 "segment of f\n", ha->host_no);
1785 goto out;
1786 }
1787
1788#if DUMP_IT_BACK
1789 mb[0] = MBC_DUMP_RAM;
1790 mb[1] = risc_address;
1791 mb[4] = cnt;
1792 mb[3] = p_tbuf & 0xffff;
1793 mb[2] = (p_tbuf >> 16) & 0xffff;
f20f43c3
CH		 1794 mb[7] = upper_32_bits(p_tbuf) & 0xffff;
1795 mb[6] = upper_32_bits(p_tbuf) >> 16;
1da177e4
LT		 1796
1797 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1798 BIT_1 | BIT_0, mb);
1799 if (err) {
1800 printk(KERN_ERR
1801 "Failed to dump partial segment of f/w\n");
1802 goto out;
1803 }
1804 sp = (uint8_t *)ha->request_ring;
1805 for (i = 0; i < (cnt << 1); i++) {
1806 if (tbuf[i] != sp[i] && warn++ < 10) {
1807 printk(KERN_ERR "%s: FW compare error @ "
1808 "byte(0x%x) loop#=%x\n",
cadbd4a5 1809 __func__, i, num);
1da177e4
LT		 1810 printk(KERN_ERR "%s: FWbyte=%x "
1811 "FWfromChip=%x\n",
cadbd4a5 1812 __func__, sp[i], tbuf[i]);
1da177e4
LT		 1813 /*break; */
1814 }
1815 }
1816#endif
1817 risc_address += cnt;
1818 risc_code_size = risc_code_size - cnt;
1bfa11db 1819 fw_data = fw_data + cnt;
1da177e4
LT		 1820 num++;
1821 }
1822
1823 out:
1824#if DUMP_IT_BACK
60ea4fb1 1825 dma_free_coherent(&ha->pdev->dev, 8000, tbuf, p_tbuf);
1da177e4
LT		 1826#endif
1827 return err;
1828}
1829
1830static int
1831qla1280_start_firmware(struct scsi_qla_host *ha)
1832{
1833 uint16_t mb[MAILBOX_REGISTER_COUNT];
1834 int err;
1835
1836 dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
cadbd4a5 1837 __func__);
1da177e4
LT		 1838
1839 /* Verify checksum of loaded RISC code. */
1840 mb[0] = MBC_VERIFY_CHECKSUM;
1841 /* mb[1] = ql12_risc_code_addr01; */
1bfa11db 1842 mb[1] = ha->fwstart;
1da177e4
LT		 1843 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1844 if (err) {
2b55cac3 1845 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1da177e4
LT		 1846 return err;
1847 }
1848
1849 /* Start firmware execution. */
cadbd4a5 1850 dprintk(1, "%s: start firmware running.\n", __func__);
1da177e4 1851 mb[0] = MBC_EXECUTE_FIRMWARE;
1bfa11db 1852 mb[1] = ha->fwstart;
1da177e4
LT		 1853 err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1854 if (err) {
1855 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1856 ha->host_no);
1857 }
1858
1859 return err;
1860}
1861
1862static int
1863qla1280_load_firmware(struct scsi_qla_host *ha)
1864{
421e33d0 1865 /* enter with host_lock taken */
5c79d615 1866 int err;
1da177e4
LT		 1867
1868 err = qla1280_chip_diag(ha);
1869 if (err)
1870 goto out;
1871 if (IS_ISP1040(ha))
1872 err = qla1280_load_firmware_pio(ha);
1873 else
1874 err = qla1280_load_firmware_dma(ha);
1875 if (err)
1876 goto out;
1877 err = qla1280_start_firmware(ha);
1878 out:
1879 return err;
1880}
1881
1882/*
1883 * Initialize rings
1884 *
1885 * Input:
1886 * ha = adapter block pointer.
1887 * ha->request_ring = request ring virtual address
1888 * ha->response_ring = response ring virtual address
1889 * ha->request_dma = request ring physical address
1890 * ha->response_dma = response ring physical address
1891 *
1892 * Returns:
1893 * 0 = success.
1894 */
1895static int
1896qla1280_init_rings(struct scsi_qla_host *ha)
1897{
1898 uint16_t mb[MAILBOX_REGISTER_COUNT];
1899 int status = 0;
1900
1901 ENTER("qla1280_init_rings");
1902
1903 /* Clear outstanding commands array. */
1904 memset(ha->outstanding_cmds, 0,
1905 sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1906
1907 /* Initialize request queue. */
1908 ha->request_ring_ptr = ha->request_ring;
1909 ha->req_ring_index = 0;
1910 ha->req_q_cnt = REQUEST_ENTRY_CNT;
1911 /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1912 mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1913 mb[1] = REQUEST_ENTRY_CNT;
1914 mb[3] = ha->request_dma & 0xffff;
1915 mb[2] = (ha->request_dma >> 16) & 0xffff;
1916 mb[4] = 0;
f20f43c3
CH		 1917 mb[7] = upper_32_bits(ha->request_dma) & 0xffff;
1918 mb[6] = upper_32_bits(ha->request_dma) >> 16;
1da177e4
LT		 1919 if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1920 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1921 &mb[0]))) {
1922 /* Initialize response queue. */
1923 ha->response_ring_ptr = ha->response_ring;
1924 ha->rsp_ring_index = 0;
1925 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1926 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1927 mb[1] = RESPONSE_ENTRY_CNT;
1928 mb[3] = ha->response_dma & 0xffff;
1929 mb[2] = (ha->response_dma >> 16) & 0xffff;
1930 mb[5] = 0;
f20f43c3
CH		 1931 mb[7] = upper_32_bits(ha->response_dma) & 0xffff;
1932 mb[6] = upper_32_bits(ha->response_dma) >> 16;
1da177e4
LT		 1933 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1934 BIT_3 | BIT_2 | BIT_1 | BIT_0,
1935 &mb[0]);
1936 }
1937
1938 if (status)
1939 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1940
1941 LEAVE("qla1280_init_rings");
1942 return status;
1943}
1944
1945static void
1946qla1280_print_settings(struct nvram *nv)
1947{
1948 dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1949 nv->bus[0].config_1.initiator_id);
1950 dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1951 nv->bus[1].config_1.initiator_id);
1952
1953 dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1954 nv->bus[0].bus_reset_delay);
1955 dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1956 nv->bus[1].bus_reset_delay);
1957
1958 dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1959 dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1960 dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1961 dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1962
1963 dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1964 nv->bus[0].config_2.async_data_setup_time);
1965 dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1966 nv->bus[1].config_2.async_data_setup_time);
1967
1968 dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1969 nv->bus[0].config_2.req_ack_active_negation);
1970 dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1971 nv->bus[1].config_2.req_ack_active_negation);
1972
1973 dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1974 nv->bus[0].config_2.data_line_active_negation);
1975 dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1976 nv->bus[1].config_2.data_line_active_negation);
1977
1978 dprintk(1, "qla1280 : disable loading risc code=%d\n",
1979 nv->cntr_flags_1.disable_loading_risc_code);
1980
1981 dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1982 nv->cntr_flags_1.enable_64bit_addressing);
1983
1984 dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1985 nv->bus[0].selection_timeout);
1986 dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1987 nv->bus[1].selection_timeout);
1988
1989 dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1990 nv->bus[0].max_queue_depth);
1991 dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1992 nv->bus[1].max_queue_depth);
1993}
1994
1995static void
1996qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1997{
1998 struct nvram *nv = &ha->nvram;
1999
7a34766f
CH		 2000 nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
2001 nv->bus[bus].target[target].parameter.auto_request_sense = 1;
2002 nv->bus[bus].target[target].parameter.tag_queuing = 1;
2003 nv->bus[bus].target[target].parameter.enable_sync = 1;
1da177e4 2004#if 1 /* Some SCSI Processors do not seem to like this */
7a34766f 2005 nv->bus[bus].target[target].parameter.enable_wide = 1;
1da177e4 2006#endif
1da177e4
LT		 2007 nv->bus[bus].target[target].execution_throttle =
2008 nv->bus[bus].max_queue_depth - 1;
7a34766f
CH		 2009 nv->bus[bus].target[target].parameter.parity_checking = 1;
2010 nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
1da177e4
LT		 2011
2012 if (IS_ISP1x160(ha)) {
2013 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
2014 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
2015 nv->bus[bus].target[target].sync_period = 9;
2016 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
2017 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2018 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2019 } else {
2020 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2021 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2022 nv->bus[bus].target[target].sync_period = 10;
2023 }
2024}
2025
2026static void
2027qla1280_set_defaults(struct scsi_qla_host *ha)
2028{
2029 struct nvram *nv = &ha->nvram;
2030 int bus, target;
2031
2032 dprintk(1, "Using defaults for NVRAM: \n");
2033 memset(nv, 0, sizeof(struct nvram));
2034
2035 /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2036 nv->firmware_feature.f.enable_fast_posting = 1;
2037 nv->firmware_feature.f.disable_synchronous_backoff = 1;
0888f4c3
CH		 2038 nv->termination.scsi_bus_0_control = 3;
2039 nv->termination.scsi_bus_1_control = 3;
2040 nv->termination.auto_term_support = 1;
1da177e4
LT		 2041
2042 /*
2043 * Set default FIFO magic - What appropriate values would be here
2044 * is unknown. This is what I have found testing with 12160s.
2045 *
2046 * Now, I would love the magic decoder ring for this one, the
2047 * header file provided by QLogic seems to be bogus or incomplete
2048 * at best.
2049 */
0888f4c3
CH		 2050 nv->isp_config.burst_enable = 1;
2051 if (IS_ISP1040(ha))
2052 nv->isp_config.fifo_threshold |= 3;
2053 else
2054 nv->isp_config.fifo_threshold |= 4;
2055
1da177e4
LT		 2056 if (IS_ISP1x160(ha))
2057 nv->isp_parameter = 0x01; /* fast memory enable */
2058
2059 for (bus = 0; bus < MAX_BUSES; bus++) {
2060 nv->bus[bus].config_1.initiator_id = 7;
2061 nv->bus[bus].config_2.req_ack_active_negation = 1;
2062 nv->bus[bus].config_2.data_line_active_negation = 1;
2063 nv->bus[bus].selection_timeout = 250;
af5741c6 2064 nv->bus[bus].max_queue_depth = 32;
1da177e4
LT		 2065
2066 if (IS_ISP1040(ha)) {
2067 nv->bus[bus].bus_reset_delay = 3;
2068 nv->bus[bus].config_2.async_data_setup_time = 6;
2069 nv->bus[bus].retry_delay = 1;
2070 } else {
2071 nv->bus[bus].bus_reset_delay = 5;
2072 nv->bus[bus].config_2.async_data_setup_time = 8;
2073 }
2074
2075 for (target = 0; target < MAX_TARGETS; target++)
2076 qla1280_set_target_defaults(ha, bus, target);
2077 }
2078}
2079
2080static int
2081qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2082{
2083 struct nvram *nv = &ha->nvram;
2084 uint16_t mb[MAILBOX_REGISTER_COUNT];
2085 int status, lun;
7a34766f 2086 uint16_t flag;
1da177e4
LT		 2087
2088 /* Set Target Parameters. */
2089 mb[0] = MBC_SET_TARGET_PARAMETERS;
7a34766f 2090 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1da177e4
LT		 2091
2092 /*
7a34766f
CH		 2093 * Do not enable sync and ppr for the initial INQUIRY run. We
2094 * enable this later if we determine the target actually
2095 * supports it.
1da177e4 2096 */
7a34766f
CH		 2097 mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2098 | TP_WIDE | TP_PARITY | TP_DISCONNECT);
1da177e4
LT		 2099
2100 if (IS_ISP1x160(ha))
2101 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2102 else
2103 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2104 mb[3] |= nv->bus[bus].target[target].sync_period;
7a34766f 2105 status = qla1280_mailbox_command(ha, 0x0f, mb);
1da177e4
LT		 2106
2107 /* Save Tag queuing enable flag. */
af5741c6 2108 flag = (BIT_0 << target);
7a34766f
CH		 2109 if (nv->bus[bus].target[target].parameter.tag_queuing)
2110 ha->bus_settings[bus].qtag_enables |= flag;
1da177e4
LT		 2111
2112 /* Save Device enable flag. */
2113 if (IS_ISP1x160(ha)) {
2114 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
7a34766f 2115 ha->bus_settings[bus].device_enables |= flag;
1da177e4
LT		 2116 ha->bus_settings[bus].lun_disables |= 0;
2117 } else {
2118 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
7a34766f 2119 ha->bus_settings[bus].device_enables |= flag;
1da177e4
LT		 2120 /* Save LUN disable flag. */
2121 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
7a34766f 2122 ha->bus_settings[bus].lun_disables |= flag;
1da177e4
LT		 2123 }
2124
2125 /* Set Device Queue Parameters. */
2126 for (lun = 0; lun < MAX_LUNS; lun++) {
2127 mb[0] = MBC_SET_DEVICE_QUEUE;
7a34766f
CH		 2128 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2129 mb[1] |= lun;
1da177e4
LT		 2130 mb[2] = nv->bus[bus].max_queue_depth;
2131 mb[3] = nv->bus[bus].target[target].execution_throttle;
7a34766f 2132 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1da177e4
LT		 2133 }
2134
2135 return status;
2136}
2137
2138static int
2139qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2140{
2141 struct nvram *nv = &ha->nvram;
2142 uint16_t mb[MAILBOX_REGISTER_COUNT];
2143 int target, status;
2144
2145 /* SCSI Reset Disable. */
2146 ha->bus_settings[bus].disable_scsi_reset =
2147 nv->bus[bus].config_1.scsi_reset_disable;
2148
2149 /* Initiator ID. */
2150 ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2151 mb[0] = MBC_SET_INITIATOR_ID;
2152 mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2153 ha->bus_settings[bus].id;
2154 status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2155
2156 /* Reset Delay. */
2157 ha->bus_settings[bus].bus_reset_delay =
2158 nv->bus[bus].bus_reset_delay;
2159
2160 /* Command queue depth per device. */
2161 ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2162
2163 /* Set target parameters. */
2164 for (target = 0; target < MAX_TARGETS; target++)
2165 status |= qla1280_config_target(ha, bus, target);
2166
2167 return status;
2168}
2169
2170static int
2171qla1280_nvram_config(struct scsi_qla_host *ha)
2172{
2173 struct device_reg __iomem *reg = ha->iobase;
2174 struct nvram *nv = &ha->nvram;
2175 int bus, target, status = 0;
2176 uint16_t mb[MAILBOX_REGISTER_COUNT];
1da177e4
LT		 2177
2178 ENTER("qla1280_nvram_config");
2179
2180 if (ha->nvram_valid) {
2181 /* Always force AUTO sense for LINUX SCSI */
2182 for (bus = 0; bus < MAX_BUSES; bus++)
2183 for (target = 0; target < MAX_TARGETS; target++) {
7a34766f 2184 nv->bus[bus].target[target].parameter.
1da177e4
LT		 2185 auto_request_sense = 1;
2186 }
2187 } else {
2188 qla1280_set_defaults(ha);
2189 }
2190
2191 qla1280_print_settings(nv);
2192
2193 /* Disable RISC load of firmware. */
2194 ha->flags.disable_risc_code_load =
2195 nv->cntr_flags_1.disable_loading_risc_code;
2196
2197 if (IS_ISP1040(ha)) {
2198 uint16_t hwrev, cfg1, cdma_conf, ddma_conf;
2199
2200 hwrev = RD_REG_WORD(&reg->cfg_0) & ISP_CFG0_HWMSK;
2201
0888f4c3 2202 cfg1 = RD_REG_WORD(&reg->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
1da177e4
LT		 2203 cdma_conf = RD_REG_WORD(&reg->cdma_cfg);
2204 ddma_conf = RD_REG_WORD(&reg->ddma_cfg);
2205
2206 /* Busted fifo, says mjacob. */
0888f4c3
CH		 2207 if (hwrev != ISP_CFG0_1040A)
2208 cfg1 |= nv->isp_config.fifo_threshold << 4;
2209
2210 cfg1 |= nv->isp_config.burst_enable << 2;
2211 WRT_REG_WORD(&reg->cfg_1, cfg1);
1da177e4
LT		 2212
2213 WRT_REG_WORD(&reg->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2214 WRT_REG_WORD(&reg->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2215 } else {
0888f4c3
CH		 2216 uint16_t cfg1, term;
2217
1da177e4 2218 /* Set ISP hardware DMA burst */
0888f4c3
CH		 2219 cfg1 = nv->isp_config.fifo_threshold << 4;
2220 cfg1 |= nv->isp_config.burst_enable << 2;
1da177e4
LT		 2221 /* Enable DMA arbitration on dual channel controllers */
2222 if (ha->ports > 1)
0888f4c3
CH		 2223 cfg1 |= BIT_13;
2224 WRT_REG_WORD(&reg->cfg_1, cfg1);
1da177e4
LT		 2225
2226 /* Set SCSI termination. */
0888f4c3
CH		 2227 WRT_REG_WORD(&reg->gpio_enable,
2228 BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2229 term = nv->termination.scsi_bus_1_control;
2230 term |= nv->termination.scsi_bus_0_control << 2;
2231 term |= nv->termination.auto_term_support << 7;
2232 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2233 WRT_REG_WORD(&reg->gpio_data, term);
1da177e4 2234 }
0888f4c3 2235 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
1da177e4
LT		 2236
2237 /* ISP parameter word. */
2238 mb[0] = MBC_SET_SYSTEM_PARAMETER;
2239 mb[1] = nv->isp_parameter;
2240 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2241
2242 if (IS_ISP1x40(ha)) {
2243 /* clock rate - for qla1240 and older, only */
2244 mb[0] = MBC_SET_CLOCK_RATE;
2245 mb[1] = 40;
2246 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2247 }
2248
2249 /* Firmware feature word. */
2250 mb[0] = MBC_SET_FIRMWARE_FEATURES;
7a34766f
CH		 2251 mb[1] = nv->firmware_feature.f.enable_fast_posting;
2252 mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2253 mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
1da177e4
LT		 2254#if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2255 if (ia64_platform_is("sn2")) {
2256 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
2257 "workaround\n", ha->host_no);
7a34766f 2258 mb[1] |= nv->firmware_feature.f.unused_9 << 9; /* XXX */
1da177e4
LT		 2259 }
2260#endif
7a34766f 2261 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1da177e4
LT		 2262
2263 /* Retry count and delay. */
2264 mb[0] = MBC_SET_RETRY_COUNT;
2265 mb[1] = nv->bus[0].retry_count;
2266 mb[2] = nv->bus[0].retry_delay;
2267 mb[6] = nv->bus[1].retry_count;
2268 mb[7] = nv->bus[1].retry_delay;
2269 status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2270 BIT_1 | BIT_0, &mb[0]);
2271
2272 /* ASYNC data setup time. */
2273 mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2274 mb[1] = nv->bus[0].config_2.async_data_setup_time;
2275 mb[2] = nv->bus[1].config_2.async_data_setup_time;
2276 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2277
2278 /* Active negation states. */
2279 mb[0] = MBC_SET_ACTIVE_NEGATION;
2280 mb[1] = 0;
2281 if (nv->bus[0].config_2.req_ack_active_negation)
2282 mb[1] |= BIT_5;
2283 if (nv->bus[0].config_2.data_line_active_negation)
2284 mb[1] |= BIT_4;
2285 mb[2] = 0;
2286 if (nv->bus[1].config_2.req_ack_active_negation)
2287 mb[2] |= BIT_5;
2288 if (nv->bus[1].config_2.data_line_active_negation)
2289 mb[2] |= BIT_4;
7a34766f 2290 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
1da177e4
LT		 2291
2292 mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2293 mb[1] = 2; /* Reset SCSI bus and return all outstanding IO */
7a34766f 2294 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1da177e4
LT		 2295
2296 /* thingy */
2297 mb[0] = MBC_SET_PCI_CONTROL;
7a34766f
CH		 2298 mb[1] = BIT_1; /* Data DMA Channel Burst Enable */
2299 mb[2] = BIT_1; /* Command DMA Channel Burst Enable */
2300 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
1da177e4
LT		 2301
2302 mb[0] = MBC_SET_TAG_AGE_LIMIT;
2303 mb[1] = 8;
7a34766f 2304 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1da177e4
LT		 2305
2306 /* Selection timeout. */
2307 mb[0] = MBC_SET_SELECTION_TIMEOUT;
2308 mb[1] = nv->bus[0].selection_timeout;
2309 mb[2] = nv->bus[1].selection_timeout;
7a34766f 2310 status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
1da177e4
LT		 2311
2312 for (bus = 0; bus < ha->ports; bus++)
2313 status |= qla1280_config_bus(ha, bus);
2314
2315 if (status)
2316 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2317
2318 LEAVE("qla1280_nvram_config");
2319 return status;
2320}
2321
2322/*
2323 * Get NVRAM data word
2324 * Calculates word position in NVRAM and calls request routine to
2325 * get the word from NVRAM.
2326 *
2327 * Input:
2328 * ha = adapter block pointer.
2329 * address = NVRAM word address.
2330 *
2331 * Returns:
2332 * data word.
2333 */
2334static uint16_t
2335qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2336{
2337 uint32_t nv_cmd;
2338 uint16_t data;
2339
2340 nv_cmd = address << 16;
2341 nv_cmd |= NV_READ_OP;
2342
2343 data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2344
2345 dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2346 "0x%x", data);
2347
2348 return data;
2349}
2350
2351/*
2352 * NVRAM request
2353 * Sends read command to NVRAM and gets data from NVRAM.
2354 *
2355 * Input:
2356 * ha = adapter block pointer.
2357 * nv_cmd = Bit 26 = start bit
2358 * Bit 25, 24 = opcode
2359 * Bit 23-16 = address
2360 * Bit 15-0 = write data
2361 *
2362 * Returns:
2363 * data word.
2364 */
2365static uint16_t
2366qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2367{
2368 struct device_reg __iomem *reg = ha->iobase;
2369 int cnt;
2370 uint16_t data = 0;
2371 uint16_t reg_data;
2372
2373 /* Send command to NVRAM. */
2374
2375 nv_cmd <<= 5;
2376 for (cnt = 0; cnt < 11; cnt++) {
2377 if (nv_cmd & BIT_31)
2378 qla1280_nv_write(ha, NV_DATA_OUT);
2379 else
2380 qla1280_nv_write(ha, 0);
2381 nv_cmd <<= 1;
2382 }
2383
2384 /* Read data from NVRAM. */
2385
2386 for (cnt = 0; cnt < 16; cnt++) {
2387 WRT_REG_WORD(&reg->nvram, (NV_SELECT | NV_CLOCK));
2388 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2389 NVRAM_DELAY();
2390 data <<= 1;
2391 reg_data = RD_REG_WORD(&reg->nvram);
2392 if (reg_data & NV_DATA_IN)
2393 data |= BIT_0;
2394 WRT_REG_WORD(&reg->nvram, NV_SELECT);
2395 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2396 NVRAM_DELAY();
2397 }
2398
2399 /* Deselect chip. */
2400
2401 WRT_REG_WORD(&reg->nvram, NV_DESELECT);
2402 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2403 NVRAM_DELAY();
2404
2405 return data;
2406}
2407
2408static void
2409qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2410{
2411 struct device_reg __iomem *reg = ha->iobase;
2412
2413 WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2414 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2415 NVRAM_DELAY();
2416 WRT_REG_WORD(&reg->nvram, data | NV_SELECT | NV_CLOCK);
2417 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2418 NVRAM_DELAY();
2419 WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2420 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2421 NVRAM_DELAY();
2422}
2423
2424/*
2425 * Mailbox Command
2426 * Issue mailbox command and waits for completion.
2427 *
2428 * Input:
2429 * ha = adapter block pointer.
2430 * mr = mailbox registers to load.
2431 * mb = data pointer for mailbox registers.
2432 *
2433 * Output:
2434 * mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2435 *
2436 * Returns:
2437 * 0 = success
2438 */
2439static int
2440qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2441{
2442 struct device_reg __iomem *reg = ha->iobase;
1da177e4
LT		 2443 int status = 0;
2444 int cnt;
2445 uint16_t *optr, *iptr;
2446 uint16_t __iomem *mptr;
2447 uint16_t data;
6e9a4738 2448 DECLARE_COMPLETION_ONSTACK(wait);
1da177e4
LT		 2449
2450 ENTER("qla1280_mailbox_command");
2451
2452 if (ha->mailbox_wait) {
2453 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2454 }
2455 ha->mailbox_wait = &wait;
2456
2457 /*
2458 * We really should start out by verifying that the mailbox is
2459 * available before starting sending the command data
2460 */
2461 /* Load mailbox registers. */
2462 mptr = (uint16_t __iomem *) &reg->mailbox0;
2463 iptr = mb;
2464 for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2465 if (mr & BIT_0) {
2466 WRT_REG_WORD(mptr, (*iptr));
2467 }
2468
2469 mr >>= 1;
2470 mptr++;
2471 iptr++;
2472 }
2473
2474 /* Issue set host interrupt command. */
2475
2476 /* set up a timer just in case we're really jammed */
9c6c273a
KC		 2477 timer_setup(&ha->mailbox_timer, qla1280_mailbox_timeout, 0);
2478 mod_timer(&ha->mailbox_timer, jiffies + 20 * HZ);
1da177e4 2479
2dbb04c6 2480 spin_unlock_irq(ha->host->host_lock);
1da177e4
LT		 2481 WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
2482 data = qla1280_debounce_register(&reg->istatus);
2483
2484 wait_for_completion(&wait);
9c6c273a 2485 del_timer_sync(&ha->mailbox_timer);
1da177e4 2486
2dbb04c6 2487 spin_lock_irq(ha->host->host_lock);
1da177e4
LT		 2488
2489 ha->mailbox_wait = NULL;
2490
2491 /* Check for mailbox command timeout. */
2492 if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2493 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2494 "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2495 "0x%04x\n",
2496 mb[0], ha->mailbox_out[0], RD_REG_WORD(&reg->istatus));
2497 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2498 RD_REG_WORD(&reg->mailbox0), RD_REG_WORD(&reg->mailbox1),
2499 RD_REG_WORD(&reg->mailbox2), RD_REG_WORD(&reg->mailbox3));
2500 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2501 RD_REG_WORD(&reg->mailbox4), RD_REG_WORD(&reg->mailbox5),
2502 RD_REG_WORD(&reg->mailbox6), RD_REG_WORD(&reg->mailbox7));
2503 status = 1;
2504 }
2505
2506 /* Load return mailbox registers. */
2507 optr = mb;
2508 iptr = (uint16_t *) &ha->mailbox_out[0];
2509 mr = MAILBOX_REGISTER_COUNT;
2510 memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2511
1da177e4
LT		 2512 if (ha->flags.reset_marker)
2513 qla1280_rst_aen(ha);
2514
1da177e4
LT		 2515 if (status)
2516 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2517 "0x%x ****\n", mb[0]);
2518
2519 LEAVE("qla1280_mailbox_command");
2520 return status;
2521}
2522
2523/*
2524 * qla1280_poll
2525 * Polls ISP for interrupts.
2526 *
2527 * Input:
2528 * ha = adapter block pointer.
2529 */
2530static void
2531qla1280_poll(struct scsi_qla_host *ha)
2532{
2533 struct device_reg __iomem *reg = ha->iobase;
2534 uint16_t data;
2535 LIST_HEAD(done_q);
2536
2537 /* ENTER("qla1280_poll"); */
2538
2539 /* Check for pending interrupts. */
2540 data = RD_REG_WORD(&reg->istatus);
2541 if (data & RISC_INT)
2542 qla1280_isr(ha, &done_q);
2543
2544 if (!ha->mailbox_wait) {
2545 if (ha->flags.reset_marker)
2546 qla1280_rst_aen(ha);
2547 }
2548
2549 if (!list_empty(&done_q))
2550 qla1280_done(ha);
2551
2552 /* LEAVE("qla1280_poll"); */
2553}
2554
2555/*
2556 * qla1280_bus_reset
2557 * Issue SCSI bus reset.
2558 *
2559 * Input:
2560 * ha = adapter block pointer.
2561 * bus = SCSI bus number.
2562 *
2563 * Returns:
2564 * 0 = success
2565 */
2566static int
2567qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2568{
2569 uint16_t mb[MAILBOX_REGISTER_COUNT];
2570 uint16_t reset_delay;
2571 int status;
2572
2573 dprintk(3, "qla1280_bus_reset: entered\n");
2574
2575 if (qla1280_verbose)
2576 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2577 ha->host_no, bus);
2578
2579 reset_delay = ha->bus_settings[bus].bus_reset_delay;
2580 mb[0] = MBC_BUS_RESET;
2581 mb[1] = reset_delay;
2582 mb[2] = (uint16_t) bus;
2583 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2584
2585 if (status) {
2586 if (ha->bus_settings[bus].failed_reset_count > 2)
2587 ha->bus_settings[bus].scsi_bus_dead = 1;
2588 ha->bus_settings[bus].failed_reset_count++;
2589 } else {
2dbb04c6 2590 spin_unlock_irq(ha->host->host_lock);
117e4b27 2591 ssleep(reset_delay);
2dbb04c6 2592 spin_lock_irq(ha->host->host_lock);
1da177e4
LT		 2593
2594 ha->bus_settings[bus].scsi_bus_dead = 0;
2595 ha->bus_settings[bus].failed_reset_count = 0;
2596 ha->bus_settings[bus].reset_marker = 0;
2597 /* Issue marker command. */
2598 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2599 }
2600
2601 /*
2602 * We should probably call qla1280_set_target_parameters()
2603 * here as well for all devices on the bus.
2604 */
2605
2606 if (status)
2607 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2608 else
2609 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2610
2611 return status;
2612}
2613
2614/*
2615 * qla1280_device_reset
2616 * Issue bus device reset message to the target.
2617 *
2618 * Input:
2619 * ha = adapter block pointer.
2620 * bus = SCSI BUS number.
2621 * target = SCSI ID.
2622 *
2623 * Returns:
2624 * 0 = success
2625 */
2626static int
2627qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2628{
2629 uint16_t mb[MAILBOX_REGISTER_COUNT];
2630 int status;
2631
2632 ENTER("qla1280_device_reset");
2633
2634 mb[0] = MBC_ABORT_TARGET;
2635 mb[1] = (bus ? (target | BIT_7) : target) << 8;
2636 mb[2] = 1;
2637 status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2638
2639 /* Issue marker command. */
2640 qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2641
2642 if (status)
2643 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2644
2645 LEAVE("qla1280_device_reset");
2646 return status;
2647}
2648
1da177e4
LT		 2649/*
2650 * qla1280_abort_command
2651 * Abort command aborts a specified IOCB.
2652 *
2653 * Input:
2654 * ha = adapter block pointer.
2655 * sp = SB structure pointer.
2656 *
2657 * Returns:
2658 * 0 = success
2659 */
2660static int
2661qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2662{
2663 uint16_t mb[MAILBOX_REGISTER_COUNT];
2664 unsigned int bus, target, lun;
2665 int status;
2666
2667 ENTER("qla1280_abort_command");
2668
2669 bus = SCSI_BUS_32(sp->cmd);
2670 target = SCSI_TCN_32(sp->cmd);
2671 lun = SCSI_LUN_32(sp->cmd);
2672
2673 sp->flags |= SRB_ABORT_PENDING;
2674
2675 mb[0] = MBC_ABORT_COMMAND;
2676 mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2677 mb[2] = handle >> 16;
2678 mb[3] = handle & 0xffff;
2679 status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2680
2681 if (status) {
2682 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2683 sp->flags &= ~SRB_ABORT_PENDING;
2684 }
2685
2686
2687 LEAVE("qla1280_abort_command");
2688 return status;
2689}
2690
2691/*
2692 * qla1280_reset_adapter
2693 * Reset adapter.
2694 *
2695 * Input:
2696 * ha = adapter block pointer.
2697 */
2698static void
2699qla1280_reset_adapter(struct scsi_qla_host *ha)
2700{
2701 struct device_reg __iomem *reg = ha->iobase;
2702
2703 ENTER("qla1280_reset_adapter");
2704
2705 /* Disable ISP chip */
2706 ha->flags.online = 0;
2707 WRT_REG_WORD(&reg->ictrl, ISP_RESET);
2708 WRT_REG_WORD(&reg->host_cmd,
2709 HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2710 RD_REG_WORD(&reg->id_l); /* Flush PCI write */
2711
2712 LEAVE("qla1280_reset_adapter");
2713}
2714
2715/*
2716 * Issue marker command.
2717 * Function issues marker IOCB.
2718 *
2719 * Input:
2720 * ha = adapter block pointer.
2721 * bus = SCSI BUS number
2722 * id = SCSI ID
2723 * lun = SCSI LUN
2724 * type = marker modifier
2725 */
2726static void
2727qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2728{
2729 struct mrk_entry *pkt;
2730
2731 ENTER("qla1280_marker");
2732
2733 /* Get request packet. */
2734 if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2735 pkt->entry_type = MARKER_TYPE;
2736 pkt->lun = (uint8_t) lun;
2737 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2738 pkt->modifier = type;
2739 pkt->entry_status = 0;
2740
2741 /* Issue command to ISP */
2742 qla1280_isp_cmd(ha);
2743 }
2744
2745 LEAVE("qla1280_marker");
2746}
2747
2748
2749/*
2750 * qla1280_64bit_start_scsi
2751 * The start SCSI is responsible for building request packets on
2752 * request ring and modifying ISP input pointer.
2753 *
2754 * Input:
2755 * ha = adapter block pointer.
2756 * sp = SB structure pointer.
2757 *
2758 * Returns:
2759 * 0 = success, was able to issue command.
2760 */
2761#ifdef QLA_64BIT_PTR
2762static int
2763qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2764{
2765 struct device_reg __iomem *reg = ha->iobase;
2766 struct scsi_cmnd *cmd = sp->cmd;
2767 cmd_a64_entry_t *pkt;
8d6810d3 2768 __le32 *dword_ptr;
1da177e4
LT		 2769 dma_addr_t dma_handle;
2770 int status = 0;
2771 int cnt;
2772 int req_cnt;
5c1da582 2773 int seg_cnt;
1da177e4
LT		 2774 u8 dir;
2775
2776 ENTER("qla1280_64bit_start_scsi:");
2777
2778 /* Calculate number of entries and segments required. */
2779 req_cnt = 1;
5c1da582
JS		 2780 seg_cnt = scsi_dma_map(cmd);
2781 if (seg_cnt > 0) {
1da177e4
LT		 2782 if (seg_cnt > 2) {
2783 req_cnt += (seg_cnt - 2) / 5;
2784 if ((seg_cnt - 2) % 5)
2785 req_cnt++;
2786 }
5c1da582
JS		 2787 } else if (seg_cnt < 0) {
2788 status = 1;
2789 goto out;
1da177e4
LT		 2790 }
2791
2792 if ((req_cnt + 2) >= ha->req_q_cnt) {
2793 /* Calculate number of free request entries. */
2794 cnt = RD_REG_WORD(&reg->mailbox4);
2795 if (ha->req_ring_index < cnt)
2796 ha->req_q_cnt = cnt - ha->req_ring_index;
2797 else
2798 ha->req_q_cnt =
2799 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2800 }
2801
2b55cac3
CH		 2802 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2803 ha->req_q_cnt, seg_cnt);
2804
1da177e4
LT		 2805 /* If room for request in request ring. */
2806 if ((req_cnt + 2) >= ha->req_q_cnt) {
fd65e5e9 2807 status = SCSI_MLQUEUE_HOST_BUSY;
2b55cac3 2808 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x req_q_cnt="
1da177e4
LT		 2809 "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2810 req_cnt);
2811 goto out;
2812 }
2813
2814 /* Check for room in outstanding command list. */
2815 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
9bcf0910 2816 ha->outstanding_cmds[cnt] != NULL; cnt++);
1da177e4
LT		 2817
2818 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
fd65e5e9 2819 status = SCSI_MLQUEUE_HOST_BUSY;
2b55cac3 2820 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
1da177e4
LT		 2821 "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2822 goto out;
2823 }
2824
2825 ha->outstanding_cmds[cnt] = sp;
2826 ha->req_q_cnt -= req_cnt;
2827 CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2828
2b55cac3 2829 dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
1da177e4
LT		 2830 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2831 dprintk(2, " bus %i, target %i, lun %i\n",
2832 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2833 qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2834
2835 /*
2836 * Build command packet.
2837 */
2838 pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2839
2840 pkt->entry_type = COMMAND_A64_TYPE;
2841 pkt->entry_count = (uint8_t) req_cnt;
2842 pkt->sys_define = (uint8_t) ha->req_ring_index;
2843 pkt->entry_status = 0;
2844 pkt->handle = cpu_to_le32(cnt);
2845
2846 /* Zero out remaining portion of packet. */
2847 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2848
2849 /* Set ISP command timeout. */
242f9dcb 2850 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
1da177e4
LT		 2851
2852 /* Set device target ID and LUN */
2853 pkt->lun = SCSI_LUN_32(cmd);
2854 pkt->target = SCSI_BUS_32(cmd) ?
2855 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2856
2857 /* Enable simple tag queuing if device supports it. */
2dbb04c6 2858 if (cmd->device->simple_tags)
1da177e4
LT		 2859 pkt->control_flags |= cpu_to_le16(BIT_3);
2860
2861 /* Load SCSI command packet. */
2862 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
64a87b24 2863 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
1da177e4
LT		 2864 /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2865
2866 /* Set transfer direction. */
2867 dir = qla1280_data_direction(cmd);
2868 pkt->control_flags |= cpu_to_le16(dir);
2869
2870 /* Set total data segment count. */
2871 pkt->dseg_count = cpu_to_le16(seg_cnt);
2872
2873 /*
2874 * Load data segments.
2875 */
2876 if (seg_cnt) { /* If data transfer. */
5c1da582 2877 struct scatterlist *sg, *s;
a0441891 2878 int remseg = seg_cnt;
5c1da582
JS		 2879
2880 sg = scsi_sglist(cmd);
2881
1da177e4
LT		 2882 /* Setup packet address segment pointer. */
2883 dword_ptr = (u32 *)&pkt->dseg_0_address;
2884
5c1da582
JS		 2885 /* Load command entry data segments. */
2886 for_each_sg(sg, s, seg_cnt, cnt) {
2887 if (cnt == 2)
2888 break;
2889
2890 dma_handle = sg_dma_address(s);
2891#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2892 if (ha->flags.use_pci_vchannel)
2893 sn_pci_set_vchan(ha->pdev,
2894 (unsigned long *)&dma_handle,
2895 SCSI_BUS_32(cmd));
2896#endif
2897 *dword_ptr++ =
f20f43c3 2898 cpu_to_le32(lower_32_bits(dma_handle));
5c1da582 2899 *dword_ptr++ =
f20f43c3 2900 cpu_to_le32(upper_32_bits(dma_handle));
5c1da582
JS		 2901 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
2902 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
f20f43c3
CH		 2903 cpu_to_le32(upper_32_bits(dma_handle)),
2904 cpu_to_le32(lower_32_bits(dma_handle)),
5c1da582
JS		 2905 cpu_to_le32(sg_dma_len(sg_next(s))));
2906 remseg--;
2907 }
2908 dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2909 "command packet data - b %i, t %i, l %i \n",
2910 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2911 SCSI_LUN_32(cmd));
2912 qla1280_dump_buffer(5, (char *)pkt,
2913 REQUEST_ENTRY_SIZE);
2914
2915 /*
2916 * Build continuation packets.
2917 */
2918 dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2919 "remains\n", seg_cnt);
2920
2921 while (remseg > 0) {
2922 /* Update sg start */
2923 sg = s;
2924 /* Adjust ring index. */
2925 ha->req_ring_index++;
2926 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2927 ha->req_ring_index = 0;
2928 ha->request_ring_ptr =
2929 ha->request_ring;
2930 } else
2931 ha->request_ring_ptr++;
2932
2933 pkt = (cmd_a64_entry_t *)ha->request_ring_ptr;
2934
2935 /* Zero out packet. */
2936 memset(pkt, 0, REQUEST_ENTRY_SIZE);
2937
2938 /* Load packet defaults. */
2939 ((struct cont_a64_entry *) pkt)->entry_type =
2940 CONTINUE_A64_TYPE;
2941 ((struct cont_a64_entry *) pkt)->entry_count = 1;
2942 ((struct cont_a64_entry *) pkt)->sys_define =
2943 (uint8_t)ha->req_ring_index;
2944 /* Setup packet address segment pointer. */
2945 dword_ptr =
2946 (u32 *)&((struct cont_a64_entry *) pkt)->dseg_0_address;
2947
2948 /* Load continuation entry data segments. */
2949 for_each_sg(sg, s, remseg, cnt) {
2950 if (cnt == 5)
a0441891
JA		 2951 break;
2952 dma_handle = sg_dma_address(s);
1da177e4
LT		 2953#if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2954 if (ha->flags.use_pci_vchannel)
2955 sn_pci_set_vchan(ha->pdev,
5c1da582 2956 (unsigned long *)&dma_handle,
1da177e4
LT		 2957 SCSI_BUS_32(cmd));
2958#endif
2959 *dword_ptr++ =
f20f43c3 2960 cpu_to_le32(lower_32_bits(dma_handle));
1da177e4 2961 *dword_ptr++ =
f20f43c3 2962 cpu_to_le32(upper_32_bits(dma_handle));
5c1da582
JS		 2963 *dword_ptr++ =
2964 cpu_to_le32(sg_dma_len(s));
2965 dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
f20f43c3
CH		 2966 cpu_to_le32(upper_32_bits(dma_handle)),
2967 cpu_to_le32(lower_32_bits(dma_handle)),
5c1da582 2968 cpu_to_le32(sg_dma_len(s)));
1da177e4 2969 }
5c1da582
JS		 2970 remseg -= cnt;
2971 dprintk(5, "qla1280_64bit_start_scsi: "
2972 "continuation packet data - b %i, t "
2973 "%i, l %i \n", SCSI_BUS_32(cmd),
2974 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
1da177e4
LT		 2975 qla1280_dump_buffer(5, (char *)pkt,
2976 REQUEST_ENTRY_SIZE);
2977 }
2978 } else { /* No data transfer */
2979 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
2980 "packet data - b %i, t %i, l %i \n",
2981 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2982 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
2983 }
2984 /* Adjust ring index. */
2985 ha->req_ring_index++;
2986 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
2987 ha->req_ring_index = 0;
2988 ha->request_ring_ptr = ha->request_ring;
2989 } else
2990 ha->request_ring_ptr++;
2991
2992 /* Set chip new ring index. */
2993 dprintk(2,
2994 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
2995 sp->flags |= SRB_SENT;
2996 ha->actthreads++;
2997 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
1da177e4
LT		 2998
2999 out:
3000 if (status)
3001 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3002 else
3003 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3004
3005 return status;
3006}
3007#else /* !QLA_64BIT_PTR */
3008
3009/*
3010 * qla1280_32bit_start_scsi
3011 * The start SCSI is responsible for building request packets on
3012 * request ring and modifying ISP input pointer.
3013 *
3014 * The Qlogic firmware interface allows every queue slot to have a SCSI
3015 * command and up to 4 scatter/gather (SG) entries. If we need more
3016 * than 4 SG entries, then continuation entries are used that can
3017 * hold another 7 entries each. The start routine determines if there
3018 * is eought empty slots then build the combination of requests to
3019 * fulfill the OS request.
3020 *
3021 * Input:
3022 * ha = adapter block pointer.
3023 * sp = SCSI Request Block structure pointer.
3024 *
3025 * Returns:
3026 * 0 = success, was able to issue command.
3027 */
3028static int
3029qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
3030{
3031 struct device_reg __iomem *reg = ha->iobase;
3032 struct scsi_cmnd *cmd = sp->cmd;
3033 struct cmd_entry *pkt;
8d6810d3 3034 __le32 *dword_ptr;
1da177e4
LT		 3035 int status = 0;
3036 int cnt;
3037 int req_cnt;
5c1da582 3038 int seg_cnt;
1da177e4
LT		 3039 u8 dir;
3040
3041 ENTER("qla1280_32bit_start_scsi");
3042
3043 dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3044 cmd->cmnd[0]);
3045
3046 /* Calculate number of entries and segments required. */
3a43e69c 3047 req_cnt = 1;
5c1da582
JS		 3048 seg_cnt = scsi_dma_map(cmd);
3049 if (seg_cnt) {
1da177e4
LT		 3050 /*
3051 * if greater than four sg entries then we need to allocate
3052 * continuation entries
3053 */
3054 if (seg_cnt > 4) {
3055 req_cnt += (seg_cnt - 4) / 7;
3056 if ((seg_cnt - 4) % 7)
3057 req_cnt++;
3058 }
3059 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3060 cmd, seg_cnt, req_cnt);
5c1da582
JS		 3061 } else if (seg_cnt < 0) {
3062 status = 1;
3063 goto out;
1da177e4
LT		 3064 }
3065
3066 if ((req_cnt + 2) >= ha->req_q_cnt) {
3067 /* Calculate number of free request entries. */
3068 cnt = RD_REG_WORD(&reg->mailbox4);
3069 if (ha->req_ring_index < cnt)
3070 ha->req_q_cnt = cnt - ha->req_ring_index;
3071 else
3072 ha->req_q_cnt =
3073 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3074 }
3075
3076 dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3077 ha->req_q_cnt, seg_cnt);
3078 /* If room for request in request ring. */
3079 if ((req_cnt + 2) >= ha->req_q_cnt) {
fd65e5e9 3080 status = SCSI_MLQUEUE_HOST_BUSY;
1da177e4
LT		 3081 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3082 "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3083 ha->req_q_cnt, req_cnt);
3084 goto out;
3085 }
3086
3087 /* Check for empty slot in outstanding command list. */
3088 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3089 (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3090
3091 if (cnt >= MAX_OUTSTANDING_COMMANDS) {
fd65e5e9 3092 status = SCSI_MLQUEUE_HOST_BUSY;
1da177e4
LT		 3093 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3094 "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3095 goto out;
3096 }
3097
3098 CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3099 ha->outstanding_cmds[cnt] = sp;
3100 ha->req_q_cnt -= req_cnt;
3101
3102 /*
3103 * Build command packet.
3104 */
3105 pkt = (struct cmd_entry *) ha->request_ring_ptr;
3106
3107 pkt->entry_type = COMMAND_TYPE;
3108 pkt->entry_count = (uint8_t) req_cnt;
3109 pkt->sys_define = (uint8_t) ha->req_ring_index;
3110 pkt->entry_status = 0;
3111 pkt->handle = cpu_to_le32(cnt);
3112
3113 /* Zero out remaining portion of packet. */
3114 memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3115
3116 /* Set ISP command timeout. */
242f9dcb 3117 pkt->timeout = cpu_to_le16(cmd->request->timeout/HZ);
1da177e4
LT		 3118
3119 /* Set device target ID and LUN */
3120 pkt->lun = SCSI_LUN_32(cmd);
3121 pkt->target = SCSI_BUS_32(cmd) ?
3122 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3123
3124 /* Enable simple tag queuing if device supports it. */
2dbb04c6 3125 if (cmd->device->simple_tags)
1da177e4
LT		 3126 pkt->control_flags |= cpu_to_le16(BIT_3);
3127
3128 /* Load SCSI command packet. */
3129 pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
64a87b24 3130 memcpy(pkt->scsi_cdb, CMD_CDBP(cmd), CMD_CDBLEN(cmd));
1da177e4
LT		 3131
3132 /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3133 /* Set transfer direction. */
3134 dir = qla1280_data_direction(cmd);
3135 pkt->control_flags |= cpu_to_le16(dir);
3136
3137 /* Set total data segment count. */
3138 pkt->dseg_count = cpu_to_le16(seg_cnt);
3139
3140 /*
3141 * Load data segments.
3142 */
3143 if (seg_cnt) {
5c1da582 3144 struct scatterlist *sg, *s;
a0441891 3145 int remseg = seg_cnt;
5c1da582
JS		 3146
3147 sg = scsi_sglist(cmd);
3148
1da177e4
LT		 3149 /* Setup packet address segment pointer. */
3150 dword_ptr = &pkt->dseg_0_address;
3151
5c1da582
JS		 3152 dprintk(3, "Building S/G data segments..\n");
3153 qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3154
3155 /* Load command entry data segments. */
3156 for_each_sg(sg, s, seg_cnt, cnt) {
3157 if (cnt == 4)
3158 break;
3159 *dword_ptr++ =
f20f43c3 3160 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
5c1da582
JS		 3161 *dword_ptr++ = cpu_to_le32(sg_dma_len(s));
3162 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
f20f43c3 3163 (lower_32_bits(sg_dma_address(s))),
5c1da582
JS		 3164 (sg_dma_len(s)));
3165 remseg--;
3166 }
3167 /*
3168 * Build continuation packets.
3169 */
3170 dprintk(3, "S/G Building Continuation"
3171 "...seg_cnt=0x%x remains\n", seg_cnt);
3172 while (remseg > 0) {
3173 /* Continue from end point */
3174 sg = s;
3175 /* Adjust ring index. */
3176 ha->req_ring_index++;
3177 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3178 ha->req_ring_index = 0;
3179 ha->request_ring_ptr =
3180 ha->request_ring;
3181 } else
3182 ha->request_ring_ptr++;
3183
3184 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3185
3186 /* Zero out packet. */
3187 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3188
3189 /* Load packet defaults. */
3190 ((struct cont_entry *) pkt)->
3191 entry_type = CONTINUE_TYPE;
3192 ((struct cont_entry *) pkt)->entry_count = 1;
3193
3194 ((struct cont_entry *) pkt)->sys_define =
3195 (uint8_t) ha->req_ring_index;
1da177e4 3196
5c1da582
JS		 3197 /* Setup packet address segment pointer. */
3198 dword_ptr =
3199 &((struct cont_entry *) pkt)->dseg_0_address;
3200
3201 /* Load continuation entry data segments. */
3202 for_each_sg(sg, s, remseg, cnt) {
3203 if (cnt == 7)
a0441891 3204 break;
1da177e4 3205 *dword_ptr++ =
f20f43c3 3206 cpu_to_le32(lower_32_bits(sg_dma_address(s)));
5c1da582
JS		 3207 *dword_ptr++ =
3208 cpu_to_le32(sg_dma_len(s));
3209 dprintk(1,
3210 "S/G Segment Cont. phys_addr=0x%x, "
3211 "len=0x%x\n",
f20f43c3 3212 cpu_to_le32(lower_32_bits(sg_dma_address(s))),
5c1da582 3213 cpu_to_le32(sg_dma_len(s)));
1da177e4 3214 }
5c1da582
JS		 3215 remseg -= cnt;
3216 dprintk(5, "qla1280_32bit_start_scsi: "
3217 "continuation packet data - "
3218 "scsi(%i:%i:%i)\n", SCSI_BUS_32(cmd),
3219 SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3220 qla1280_dump_buffer(5, (char *)pkt,
3221 REQUEST_ENTRY_SIZE);
1da177e4
LT		 3222 }
3223 } else { /* No data transfer at all */
3224 dprintk(5, "qla1280_32bit_start_scsi: No data, command "
3225 "packet data - \n");
3226 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3227 }
3228 dprintk(5, "qla1280_32bit_start_scsi: First IOCB block:\n");
3229 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3230 REQUEST_ENTRY_SIZE);
3231
3232 /* Adjust ring index. */
3233 ha->req_ring_index++;
3234 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3235 ha->req_ring_index = 0;
3236 ha->request_ring_ptr = ha->request_ring;
3237 } else
3238 ha->request_ring_ptr++;
3239
3240 /* Set chip new ring index. */
3241 dprintk(2, "qla1280_32bit_start_scsi: Wakeup RISC "
3242 "for pending command\n");
3243 sp->flags |= SRB_SENT;
3244 ha->actthreads++;
3245 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
1da177e4
LT		 3246
3247out:
3248 if (status)
3249 dprintk(2, "qla1280_32bit_start_scsi: **** FAILED ****\n");
3250
3251 LEAVE("qla1280_32bit_start_scsi");
3252
3253 return status;
3254}
3255#endif
3256
3257/*
3258 * qla1280_req_pkt
3259 * Function is responsible for locking ring and
3260 * getting a zeroed out request packet.
3261 *
3262 * Input:
3263 * ha = adapter block pointer.
3264 *
3265 * Returns:
3266 * 0 = failed to get slot.
3267 */
3268static request_t *
3269qla1280_req_pkt(struct scsi_qla_host *ha)
3270{
3271 struct device_reg __iomem *reg = ha->iobase;
3272 request_t *pkt = NULL;
3273 int cnt;
3274 uint32_t timer;
3275
3276 ENTER("qla1280_req_pkt");
3277
3278 /*
3279 * This can be called from interrupt context, damn it!!!
3280 */
3281 /* Wait for 30 seconds for slot. */
3282 for (timer = 15000000; timer; timer--) {
3283 if (ha->req_q_cnt > 0) {
3284 /* Calculate number of free request entries. */
3285 cnt = RD_REG_WORD(&reg->mailbox4);
3286 if (ha->req_ring_index < cnt)
3287 ha->req_q_cnt = cnt - ha->req_ring_index;
3288 else
3289 ha->req_q_cnt =
3290 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3291 }
3292
3293 /* Found empty request ring slot? */
3294 if (ha->req_q_cnt > 0) {
3295 ha->req_q_cnt--;
3296 pkt = ha->request_ring_ptr;
3297
3298 /* Zero out packet. */
3299 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3300
3301 /*
3302 * How can this be right when we have a ring
3303 * size of 512???
3304 */
3305 /* Set system defined field. */
3306 pkt->sys_define = (uint8_t) ha->req_ring_index;
3307
3308 /* Set entry count. */
3309 pkt->entry_count = 1;
3310
3311 break;
3312 }
3313
3314 udelay(2); /* 10 */
3315
3316 /* Check for pending interrupts. */
3317 qla1280_poll(ha);
3318 }
3319
3320 if (!pkt)
3321 dprintk(2, "qla1280_req_pkt: **** FAILED ****\n");
3322 else
3323 dprintk(3, "qla1280_req_pkt: exiting normally\n");
3324
3325 return pkt;
3326}
3327
3328/*
3329 * qla1280_isp_cmd
3330 * Function is responsible for modifying ISP input pointer.
3331 * Releases ring lock.
3332 *
3333 * Input:
3334 * ha = adapter block pointer.
3335 */
3336static void
3337qla1280_isp_cmd(struct scsi_qla_host *ha)
3338{
3339 struct device_reg __iomem *reg = ha->iobase;
3340
3341 ENTER("qla1280_isp_cmd");
3342
3343 dprintk(5, "qla1280_isp_cmd: IOCB data:\n");
3344 qla1280_dump_buffer(5, (char *)ha->request_ring_ptr,
3345 REQUEST_ENTRY_SIZE);
3346
3347 /* Adjust ring index. */
3348 ha->req_ring_index++;
3349 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3350 ha->req_ring_index = 0;
3351 ha->request_ring_ptr = ha->request_ring;
3352 } else
3353 ha->request_ring_ptr++;
3354
3355 /*
3356 * Update request index to mailbox4 (Request Queue In).
1da177e4
LT		 3357 */
3358 WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
1da177e4
LT		 3359
3360 LEAVE("qla1280_isp_cmd");
3361}
3362
3363/****************************************************************************/
3364/* Interrupt Service Routine. */
3365/****************************************************************************/
3366
3367/****************************************************************************
3368 * qla1280_isr
3369 * Calls I/O done on command completion.
3370 *
3371 * Input:
3372 * ha = adapter block pointer.
3373 * done_q = done queue.
3374 ****************************************************************************/
3375static void
3376qla1280_isr(struct scsi_qla_host *ha, struct list_head *done_q)
3377{
3378 struct device_reg __iomem *reg = ha->iobase;
3379 struct response *pkt;
3380 struct srb *sp = NULL;
3381 uint16_t mailbox[MAILBOX_REGISTER_COUNT];
3382 uint16_t *wptr;
3383 uint32_t index;
3384 u16 istatus;
3385
3386 ENTER("qla1280_isr");
3387
3388 istatus = RD_REG_WORD(&reg->istatus);
3389 if (!(istatus & (RISC_INT | PCI_INT)))
3390 return;
3391
3392 /* Save mailbox register 5 */
3393 mailbox[5] = RD_REG_WORD(&reg->mailbox5);
3394
3395 /* Check for mailbox interrupt. */
3396
3397 mailbox[0] = RD_REG_WORD_dmasync(&reg->semaphore);
3398
3399 if (mailbox[0] & BIT_0) {
3400 /* Get mailbox data. */
3401 /* dprintk(1, "qla1280_isr: In Get mailbox data \n"); */
3402
3403 wptr = &mailbox[0];
3404 *wptr++ = RD_REG_WORD(&reg->mailbox0);
3405 *wptr++ = RD_REG_WORD(&reg->mailbox1);
3406 *wptr = RD_REG_WORD(&reg->mailbox2);
3407 if (mailbox[0] != MBA_SCSI_COMPLETION) {
3408 wptr++;
3409 *wptr++ = RD_REG_WORD(&reg->mailbox3);
3410 *wptr++ = RD_REG_WORD(&reg->mailbox4);
3411 wptr++;
3412 *wptr++ = RD_REG_WORD(&reg->mailbox6);
3413 *wptr = RD_REG_WORD(&reg->mailbox7);
3414 }
3415
3416 /* Release mailbox registers. */
3417
3418 WRT_REG_WORD(&reg->semaphore, 0);
3419 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
3420
3421 dprintk(5, "qla1280_isr: mailbox interrupt mailbox[0] = 0x%x",
3422 mailbox[0]);
3423
3424 /* Handle asynchronous event */
3425 switch (mailbox[0]) {
3426 case MBA_SCSI_COMPLETION: /* Response completion */
3427 dprintk(5, "qla1280_isr: mailbox SCSI response "
3428 "completion\n");
3429
3430 if (ha->flags.online) {
3431 /* Get outstanding command index. */
3432 index = mailbox[2] << 16 | mailbox[1];
3433
3434 /* Validate handle. */
3435 if (index < MAX_OUTSTANDING_COMMANDS)
3436 sp = ha->outstanding_cmds[index];
3437 else
3438 sp = NULL;
3439
3440 if (sp) {
3441 /* Free outstanding command slot. */
3442 ha->outstanding_cmds[index] = NULL;
3443
3444 /* Save ISP completion status */
3445 CMD_RESULT(sp->cmd) = 0;
413e6e18 3446 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
1da177e4
LT		 3447
3448 /* Place block on done queue */
3449 list_add_tail(&sp->list, done_q);
3450 } else {
3451 /*
3452 * If we get here we have a real problem!
3453 */
3454 printk(KERN_WARNING
fd65e5e9 3455 "qla1280: ISP invalid handle\n");
1da177e4
LT		 3456 }
3457 }
3458 break;
3459
3460 case MBA_BUS_RESET: /* SCSI Bus Reset */
3461 ha->flags.reset_marker = 1;
3462 index = mailbox[6] & BIT_0;
3463 ha->bus_settings[index].reset_marker = 1;
3464
3465 printk(KERN_DEBUG "qla1280_isr(): index %i "
3466 "asynchronous BUS_RESET\n", index);
3467 break;
3468
3469 case MBA_SYSTEM_ERR: /* System Error */
3470 printk(KERN_WARNING
3471 "qla1280: ISP System Error - mbx1=%xh, mbx2="
3472 "%xh, mbx3=%xh\n", mailbox[1], mailbox[2],
3473 mailbox[3]);
3474 break;
3475
3476 case MBA_REQ_TRANSFER_ERR: /* Request Transfer Error */
3477 printk(KERN_WARNING
3478 "qla1280: ISP Request Transfer Error\n");
3479 break;
3480
3481 case MBA_RSP_TRANSFER_ERR: /* Response Transfer Error */
3482 printk(KERN_WARNING
3483 "qla1280: ISP Response Transfer Error\n");
3484 break;
3485
3486 case MBA_WAKEUP_THRES: /* Request Queue Wake-up */
3487 dprintk(2, "qla1280_isr: asynchronous WAKEUP_THRES\n");
3488 break;
3489
3490 case MBA_TIMEOUT_RESET: /* Execution Timeout Reset */
3491 dprintk(2,
3492 "qla1280_isr: asynchronous TIMEOUT_RESET\n");
3493 break;
3494
3495 case MBA_DEVICE_RESET: /* Bus Device Reset */
3496 printk(KERN_INFO "qla1280_isr(): asynchronous "
3497 "BUS_DEVICE_RESET\n");
3498
3499 ha->flags.reset_marker = 1;
3500 index = mailbox[6] & BIT_0;
3501 ha->bus_settings[index].reset_marker = 1;
3502 break;
3503
3504 case MBA_BUS_MODE_CHANGE:
3505 dprintk(2,
3506 "qla1280_isr: asynchronous BUS_MODE_CHANGE\n");
3507 break;
3508
3509 default:
3510 /* dprintk(1, "qla1280_isr: default case of switch MB \n"); */
3511 if (mailbox[0] < MBA_ASYNC_EVENT) {
3512 wptr = &mailbox[0];
3513 memcpy((uint16_t *) ha->mailbox_out, wptr,
3514 MAILBOX_REGISTER_COUNT *
3515 sizeof(uint16_t));
3516
3517 if(ha->mailbox_wait != NULL)
3518 complete(ha->mailbox_wait);
3519 }
3520 break;
3521 }
3522 } else {
3523 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
3524 }
3525
3526 /*
3527 * We will receive interrupts during mailbox testing prior to
3528 * the card being marked online, hence the double check.
3529 */
3530 if (!(ha->flags.online && !ha->mailbox_wait)) {
3531 dprintk(2, "qla1280_isr: Response pointer Error\n");
3532 goto out;
3533 }
3534
3535 if (mailbox[5] >= RESPONSE_ENTRY_CNT)
3536 goto out;
3537
3538 while (ha->rsp_ring_index != mailbox[5]) {
3539 pkt = ha->response_ring_ptr;
3540
3541 dprintk(5, "qla1280_isr: ha->rsp_ring_index = 0x%x, mailbox[5]"
3542 " = 0x%x\n", ha->rsp_ring_index, mailbox[5]);
3543 dprintk(5,"qla1280_isr: response packet data\n");
3544 qla1280_dump_buffer(5, (char *)pkt, RESPONSE_ENTRY_SIZE);
3545
3546 if (pkt->entry_type == STATUS_TYPE) {
3547 if ((le16_to_cpu(pkt->scsi_status) & 0xff)
3548 || pkt->comp_status || pkt->entry_status) {
3549 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3550 "0x%x mailbox[5] = 0x%x, comp_status "
3551 "= 0x%x, scsi_status = 0x%x\n",
3552 ha->rsp_ring_index, mailbox[5],
3553 le16_to_cpu(pkt->comp_status),
3554 le16_to_cpu(pkt->scsi_status));
3555 }
3556 } else {
3557 dprintk(2, "qla1280_isr: ha->rsp_ring_index = "
3558 "0x%x, mailbox[5] = 0x%x\n",
3559 ha->rsp_ring_index, mailbox[5]);
3560 dprintk(2, "qla1280_isr: response packet data\n");
3561 qla1280_dump_buffer(2, (char *)pkt,
3562 RESPONSE_ENTRY_SIZE);
3563 }
3564
3565 if (pkt->entry_type == STATUS_TYPE || pkt->entry_status) {
3566 dprintk(2, "status: Cmd %p, handle %i\n",
3567 ha->outstanding_cmds[pkt->handle]->cmd,
3568 pkt->handle);
3569 if (pkt->entry_type == STATUS_TYPE)
3570 qla1280_status_entry(ha, pkt, done_q);
3571 else
3572 qla1280_error_entry(ha, pkt, done_q);
3573 /* Adjust ring index. */
3574 ha->rsp_ring_index++;
3575 if (ha->rsp_ring_index == RESPONSE_ENTRY_CNT) {
3576 ha->rsp_ring_index = 0;
3577 ha->response_ring_ptr = ha->response_ring;
3578 } else
3579 ha->response_ring_ptr++;
3580 WRT_REG_WORD(&reg->mailbox5, ha->rsp_ring_index);
3581 }
3582 }
3583
3584 out:
3585 LEAVE("qla1280_isr");
3586}
3587
3588/*
3589 * qla1280_rst_aen
3590 * Processes asynchronous reset.
3591 *
3592 * Input:
3593 * ha = adapter block pointer.
3594 */
3595static void
3596qla1280_rst_aen(struct scsi_qla_host *ha)
3597{
3598 uint8_t bus;
3599
3600 ENTER("qla1280_rst_aen");
3601
3602 if (ha->flags.online && !ha->flags.reset_active &&
3603 !ha->flags.abort_isp_active) {
3604 ha->flags.reset_active = 1;
3605 while (ha->flags.reset_marker) {
3606 /* Issue marker command. */
3607 ha->flags.reset_marker = 0;
3608 for (bus = 0; bus < ha->ports &&
3609 !ha->flags.reset_marker; bus++) {
3610 if (ha->bus_settings[bus].reset_marker) {
3611 ha->bus_settings[bus].reset_marker = 0;
3612 qla1280_marker(ha, bus, 0, 0,
3613 MK_SYNC_ALL);
3614 }
3615 }
3616 }
3617 }
3618
3619 LEAVE("qla1280_rst_aen");
3620}
3621
3622
1da177e4
LT		 3623/*
3624 * qla1280_status_entry
3625 * Processes received ISP status entry.
3626 *
3627 * Input:
3628 * ha = adapter block pointer.
3629 * pkt = entry pointer.
3630 * done_q = done queue.
3631 */
3632static void
3633qla1280_status_entry(struct scsi_qla_host *ha, struct response *pkt,
3634 struct list_head *done_q)
3635{
3636 unsigned int bus, target, lun;
3637 int sense_sz;
3638 struct srb *sp;
3639 struct scsi_cmnd *cmd;
3640 uint32_t handle = le32_to_cpu(pkt->handle);
3641 uint16_t scsi_status = le16_to_cpu(pkt->scsi_status);
3642 uint16_t comp_status = le16_to_cpu(pkt->comp_status);
3643
3644 ENTER("qla1280_status_entry");
3645
3646 /* Validate handle. */
3647 if (handle < MAX_OUTSTANDING_COMMANDS)
3648 sp = ha->outstanding_cmds[handle];
3649 else
3650 sp = NULL;
3651
3652 if (!sp) {
3653 printk(KERN_WARNING "qla1280: Status Entry invalid handle\n");
3654 goto out;
3655 }
3656
3657 /* Free outstanding command slot. */
3658 ha->outstanding_cmds[handle] = NULL;
3659
3660 cmd = sp->cmd;
3661
3662 /* Generate LU queue on cntrl, target, LUN */
3663 bus = SCSI_BUS_32(cmd);
3664 target = SCSI_TCN_32(cmd);
3665 lun = SCSI_LUN_32(cmd);
3666
3667 if (comp_status || scsi_status) {
3668 dprintk(3, "scsi: comp_status = 0x%x, scsi_status = "
3669 "0x%x, handle = 0x%x\n", comp_status,
3670 scsi_status, handle);
3671 }
3672
7d0e11fb
JH		 3673 /* Target busy or queue full */
3674 if ((scsi_status & 0xFF) == SAM_STAT_TASK_SET_FULL ||
3675 (scsi_status & 0xFF) == SAM_STAT_BUSY) {
3676 CMD_RESULT(cmd) = scsi_status & 0xff;
1da177e4
LT		 3677 } else {
3678
3679 /* Save ISP completion status */
3680 CMD_RESULT(cmd) = qla1280_return_status(pkt, cmd);
3681
d6db3e8d 3682 if (scsi_status & SAM_STAT_CHECK_CONDITION) {
1da177e4
LT		 3683 if (comp_status != CS_ARS_FAILED) {
3684 uint16_t req_sense_length =
3685 le16_to_cpu(pkt->req_sense_length);
3686 if (req_sense_length < CMD_SNSLEN(cmd))
3687 sense_sz = req_sense_length;
3688 else
3689 /*
3690 * scsi_cmnd->sense_buffer is
3691 * 64 bytes, why only copy 63?
3692 * This looks wrong! /Jes
3693 */
3694 sense_sz = CMD_SNSLEN(cmd) - 1;
3695
3696 memcpy(cmd->sense_buffer,
3697 &pkt->req_sense_data, sense_sz);
3698 } else
3699 sense_sz = 0;
3700 memset(cmd->sense_buffer + sense_sz, 0,
b80ca4f7 3701 SCSI_SENSE_BUFFERSIZE - sense_sz);
1da177e4
LT		 3702
3703 dprintk(2, "qla1280_status_entry: Check "
3704 "condition Sense data, b %i, t %i, "
3705 "l %i\n", bus, target, lun);
3706 if (sense_sz)
3707 qla1280_dump_buffer(2,
3708 (char *)cmd->sense_buffer,
3709 sense_sz);
3710 }
3711 }
3712
413e6e18
MR		 3713 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3714
1da177e4
LT		 3715 /* Place command on done queue. */
3716 list_add_tail(&sp->list, done_q);
3717 out:
3718 LEAVE("qla1280_status_entry");
3719}
3720
3721/*
3722 * qla1280_error_entry
3723 * Processes error entry.
3724 *
3725 * Input:
3726 * ha = adapter block pointer.
3727 * pkt = entry pointer.
3728 * done_q = done queue.
3729 */
3730static void
3731qla1280_error_entry(struct scsi_qla_host *ha, struct response *pkt,
3732 struct list_head *done_q)
3733{
3734 struct srb *sp;
3735 uint32_t handle = le32_to_cpu(pkt->handle);
3736
3737 ENTER("qla1280_error_entry");
3738
3739 if (pkt->entry_status & BIT_3)
3740 dprintk(2, "qla1280_error_entry: BAD PAYLOAD flag error\n");
3741 else if (pkt->entry_status & BIT_2)
3742 dprintk(2, "qla1280_error_entry: BAD HEADER flag error\n");
3743 else if (pkt->entry_status & BIT_1)
3744 dprintk(2, "qla1280_error_entry: FULL flag error\n");
3745 else
3746 dprintk(2, "qla1280_error_entry: UNKNOWN flag error\n");
3747
3748 /* Validate handle. */
3749 if (handle < MAX_OUTSTANDING_COMMANDS)
3750 sp = ha->outstanding_cmds[handle];
3751 else
3752 sp = NULL;
3753
3754 if (sp) {
3755 /* Free outstanding command slot. */
3756 ha->outstanding_cmds[handle] = NULL;
3757
3758 /* Bad payload or header */
3759 if (pkt->entry_status & (BIT_3 + BIT_2)) {
3760 /* Bad payload or header, set error status. */
3761 /* CMD_RESULT(sp->cmd) = CS_BAD_PAYLOAD; */
3762 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3763 } else if (pkt->entry_status & BIT_1) { /* FULL flag */
3764 CMD_RESULT(sp->cmd) = DID_BUS_BUSY << 16;
3765 } else {
3766 /* Set error status. */
3767 CMD_RESULT(sp->cmd) = DID_ERROR << 16;
3768 }
3769
413e6e18
MR		 3770 CMD_HANDLE(sp->cmd) = COMPLETED_HANDLE;
3771
1da177e4
LT		 3772 /* Place command on done queue. */
3773 list_add_tail(&sp->list, done_q);
3774 }
3775#ifdef QLA_64BIT_PTR
3776 else if (pkt->entry_type == COMMAND_A64_TYPE) {
3777 printk(KERN_WARNING "!qla1280: Error Entry invalid handle");
3778 }
3779#endif
3780
3781 LEAVE("qla1280_error_entry");
3782}
3783
3784/*
3785 * qla1280_abort_isp
3786 * Resets ISP and aborts all outstanding commands.
3787 *
3788 * Input:
3789 * ha = adapter block pointer.
3790 *
3791 * Returns:
3792 * 0 = success
3793 */
3794static int
3795qla1280_abort_isp(struct scsi_qla_host *ha)
3796{
3797 struct device_reg __iomem *reg = ha->iobase;
3798 struct srb *sp;
3799 int status = 0;
3800 int cnt;
3801 int bus;
3802
3803 ENTER("qla1280_abort_isp");
3804
3805 if (ha->flags.abort_isp_active || !ha->flags.online)
3806 goto out;
3807
3808 ha->flags.abort_isp_active = 1;
3809
3810 /* Disable ISP interrupts. */
3811 qla1280_disable_intrs(ha);
3812 WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
3813 RD_REG_WORD(&reg->id_l);
3814
3815 printk(KERN_INFO "scsi(%li): dequeuing outstanding commands\n",
3816 ha->host_no);
3817 /* Dequeue all commands in outstanding command list. */
3818 for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS; cnt++) {
3819 struct scsi_cmnd *cmd;
3820 sp = ha->outstanding_cmds[cnt];
3821 if (sp) {
1da177e4
LT		 3822 cmd = sp->cmd;
3823 CMD_RESULT(cmd) = DID_RESET << 16;
413e6e18 3824 CMD_HANDLE(cmd) = COMPLETED_HANDLE;
1da177e4 3825 ha->outstanding_cmds[cnt] = NULL;
413e6e18 3826 list_add_tail(&sp->list, &ha->done_q);
1da177e4
LT		 3827 }
3828 }
3829
413e6e18
MR		 3830 qla1280_done(ha);
3831
1da177e4
LT		 3832 status = qla1280_load_firmware(ha);
3833 if (status)
3834 goto out;
3835
3836 /* Setup adapter based on NVRAM parameters. */
3837 qla1280_nvram_config (ha);
3838
3839 status = qla1280_init_rings(ha);
3840 if (status)
3841 goto out;
3842
3843 /* Issue SCSI reset. */
3844 for (bus = 0; bus < ha->ports; bus++)
3845 qla1280_bus_reset(ha, bus);
3846
3847 ha->flags.abort_isp_active = 0;
3848 out:
3849 if (status) {
3850 printk(KERN_WARNING
3851 "qla1280: ISP error recovery failed, board disabled");
3852 qla1280_reset_adapter(ha);
3853 dprintk(2, "qla1280_abort_isp: **** FAILED ****\n");
3854 }
3855
3856 LEAVE("qla1280_abort_isp");
3857 return status;
3858}
3859
3860
3861/*
3862 * qla1280_debounce_register
3863 * Debounce register.
3864 *
3865 * Input:
3866 * port = register address.
3867 *
3868 * Returns:
3869 * register value.
3870 */
3871static u16
3872qla1280_debounce_register(volatile u16 __iomem * addr)
3873{
3874 volatile u16 ret;
3875 volatile u16 ret2;
3876
3877 ret = RD_REG_WORD(addr);
3878 ret2 = RD_REG_WORD(addr);
3879
3880 if (ret == ret2)
3881 return ret;
3882
3883 do {
3884 cpu_relax();
3885 ret = RD_REG_WORD(addr);
3886 ret2 = RD_REG_WORD(addr);
3887 } while (ret != ret2);
3888
3889 return ret;
3890}
3891
3892
3893/************************************************************************
3894 * qla1280_check_for_dead_scsi_bus *
3895 * *
3896 * This routine checks for a dead SCSI bus *
3897 ************************************************************************/
3898#define SET_SXP_BANK 0x0100
3899#define SCSI_PHASE_INVALID 0x87FF
3900static int
3901qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *ha, unsigned int bus)
3902{
3903 uint16_t config_reg, scsi_control;
3904 struct device_reg __iomem *reg = ha->iobase;
3905
3906 if (ha->bus_settings[bus].scsi_bus_dead) {
3907 WRT_REG_WORD(&reg->host_cmd, HC_PAUSE_RISC);
3908 config_reg = RD_REG_WORD(&reg->cfg_1);
3909 WRT_REG_WORD(&reg->cfg_1, SET_SXP_BANK);
3910 scsi_control = RD_REG_WORD(&reg->scsiControlPins);
3911 WRT_REG_WORD(&reg->cfg_1, config_reg);
3912 WRT_REG_WORD(&reg->host_cmd, HC_RELEASE_RISC);
3913
3914 if (scsi_control == SCSI_PHASE_INVALID) {
3915 ha->bus_settings[bus].scsi_bus_dead = 1;
1da177e4
LT		 3916 return 1; /* bus is dead */
3917 } else {
3918 ha->bus_settings[bus].scsi_bus_dead = 0;
3919 ha->bus_settings[bus].failed_reset_count = 0;
3920 }
3921 }
3922 return 0; /* bus is not dead */
3923}
3924
3925static void
3926qla1280_get_target_parameters(struct scsi_qla_host *ha,
3927 struct scsi_device *device)
3928{
3929 uint16_t mb[MAILBOX_REGISTER_COUNT];
3930 int bus, target, lun;
3931
3932 bus = device->channel;
3933 target = device->id;
3934 lun = device->lun;
3935
3936
3937 mb[0] = MBC_GET_TARGET_PARAMETERS;
3938 mb[1] = (uint16_t) (bus ? target | BIT_7 : target);
3939 mb[1] <<= 8;
3940 qla1280_mailbox_command(ha, BIT_6 | BIT_3 | BIT_2 | BIT_1 | BIT_0,
3941 &mb[0]);
3942
3943 printk(KERN_INFO "scsi(%li:%d:%d:%d):", ha->host_no, bus, target, lun);
3944
3945 if (mb[3] != 0) {
3946 printk(" Sync: period %d, offset %d",
3947 (mb[3] & 0xff), (mb[3] >> 8));
3948 if (mb[2] & BIT_13)
3949 printk(", Wide");
3950 if ((mb[2] & BIT_5) && ((mb[6] >> 8) & 0xff) >= 2)
3951 printk(", DT");
3952 } else
3953 printk(" Async");
3954
2dbb04c6 3955 if (device->simple_tags)
1da177e4
LT		 3956 printk(", Tagged queuing: depth %d", device->queue_depth);
3957 printk("\n");
3958}
3959
3960
3961#if DEBUG_QLA1280
3962static void
3963__qla1280_dump_buffer(char *b, int size)
3964{
3965 int cnt;
3966 u8 c;
3967
3968 printk(KERN_DEBUG " 0 1 2 3 4 5 6 7 8 9 Ah "
3969 "Bh Ch Dh Eh Fh\n");
3970 printk(KERN_DEBUG "---------------------------------------------"
3971 "------------------\n");
3972
3973 for (cnt = 0; cnt < size;) {
3974 c = *b++;
3975
3976 printk("0x%02x", c);
3977 cnt++;
3978 if (!(cnt % 16))
3979 printk("\n");
3980 else
3981 printk(" ");
3982 }
3983 if (cnt % 16)
3984 printk("\n");
3985}
3986
3987/**************************************************************************
3988 * ql1280_print_scsi_cmd
3989 *
3990 **************************************************************************/
3991static void
3992__qla1280_print_scsi_cmd(struct scsi_cmnd *cmd)
3993{
3994 struct scsi_qla_host *ha;
3995 struct Scsi_Host *host = CMD_HOST(cmd);
3996 struct srb *sp;
3997 /* struct scatterlist *sg; */
3998
3999 int i;
4000 ha = (struct scsi_qla_host *)host->hostdata;
4001
4002 sp = (struct srb *)CMD_SP(cmd);
4003 printk("SCSI Command @= 0x%p, Handle=0x%p\n", cmd, CMD_HANDLE(cmd));
4004 printk(" chan=%d, target = 0x%02x, lun = 0x%02x, cmd_len = 0x%02x\n",
4005 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd),
4006 CMD_CDBLEN(cmd));
4007 printk(" CDB = ");
4008 for (i = 0; i < cmd->cmd_len; i++) {
4009 printk("0x%02x ", cmd->cmnd[i]);
4010 }
5c1da582 4011 printk(" seg_cnt =%d\n", scsi_sg_count(cmd));
1da177e4 4012 printk(" request buffer=0x%p, request buffer len=0x%x\n",
5c1da582 4013 scsi_sglist(cmd), scsi_bufflen(cmd));
1da177e4
LT		 4014 /* if (cmd->use_sg)
4015 {
4016 sg = (struct scatterlist *) cmd->request_buffer;
4017 printk(" SG buffer: \n");
4018 qla1280_dump_buffer(1, (char *)sg, (cmd->use_sg*sizeof(struct scatterlist)));
4019 } */
4020 printk(" tag=%d, transfersize=0x%x \n",
4021 cmd->tag, cmd->transfersize);
5cd049a5 4022 printk(" SP=0x%p\n", CMD_SP(cmd));
1da177e4
LT		 4023 printk(" underflow size = 0x%x, direction=0x%x\n",
4024 cmd->underflow, cmd->sc_data_direction);
4025}
4026
4027/**************************************************************************
4028 * ql1280_dump_device
4029 *
4030 **************************************************************************/
4031static void
4032ql1280_dump_device(struct scsi_qla_host *ha)
4033{
4034
4035 struct scsi_cmnd *cp;
4036 struct srb *sp;
4037 int i;
4038
4039 printk(KERN_DEBUG "Outstanding Commands on controller:\n");
4040
4041 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
4042 if ((sp = ha->outstanding_cmds[i]) == NULL)
4043 continue;
4044 if ((cp = sp->cmd) == NULL)
4045 continue;
4046 qla1280_print_scsi_cmd(1, cp);
4047 }
4048}
4049#endif
4050
4051
4052enum tokens {
4053 TOKEN_NVRAM,
4054 TOKEN_SYNC,
4055 TOKEN_WIDE,
4056 TOKEN_PPR,
4057 TOKEN_VERBOSE,
4058 TOKEN_DEBUG,
4059};
4060
4061struct setup_tokens {
4062 char *token;
4063 int val;
4064};
4065
4066static struct setup_tokens setup_token[] __initdata =
4067{
4068 { "nvram", TOKEN_NVRAM },
4069 { "sync", TOKEN_SYNC },
4070 { "wide", TOKEN_WIDE },
4071 { "ppr", TOKEN_PPR },
4072 { "verbose", TOKEN_VERBOSE },
4073 { "debug", TOKEN_DEBUG },
4074};
4075
4076
4077/**************************************************************************
4078 * qla1280_setup
4079 *
4080 * Handle boot parameters. This really needs to be changed so one
4081 * can specify per adapter parameters.
4082 **************************************************************************/
4083static int __init
4084qla1280_setup(char *s)
4085{
4086 char *cp, *ptr;
4087 unsigned long val;
4088 int toke;
4089
4090 cp = s;
4091
4092 while (cp && (ptr = strchr(cp, ':'))) {
4093 ptr++;
4094 if (!strcmp(ptr, "yes")) {
4095 val = 0x10000;
4096 ptr += 3;
4097 } else if (!strcmp(ptr, "no")) {
4098 val = 0;
4099 ptr += 2;
4100 } else
4101 val = simple_strtoul(ptr, &ptr, 0);
4102
4103 switch ((toke = qla1280_get_token(cp))) {
4104 case TOKEN_NVRAM:
4105 if (!val)
4106 driver_setup.no_nvram = 1;
4107 break;
4108 case TOKEN_SYNC:
4109 if (!val)
4110 driver_setup.no_sync = 1;
4111 else if (val != 0x10000)
4112 driver_setup.sync_mask = val;
4113 break;
4114 case TOKEN_WIDE:
4115 if (!val)
4116 driver_setup.no_wide = 1;
4117 else if (val != 0x10000)
4118 driver_setup.wide_mask = val;
4119 break;
4120 case TOKEN_PPR:
4121 if (!val)
4122 driver_setup.no_ppr = 1;
4123 else if (val != 0x10000)
4124 driver_setup.ppr_mask = val;
4125 break;
4126 case TOKEN_VERBOSE:
4127 qla1280_verbose = val;
4128 break;
4129 default:
4130 printk(KERN_INFO "qla1280: unknown boot option %s\n",
4131 cp);
4132 }
4133
4134 cp = strchr(ptr, ';');
4135 if (cp)
4136 cp++;
4137 else {
4138 break;
4139 }
4140 }
4141 return 1;
4142}
4143
4144
f58f8313 4145static int __init
1da177e4
LT		 4146qla1280_get_token(char *str)
4147{
4148 char *sep;
4149 long ret = -1;
6391a113 4150 int i;
1da177e4
LT		 4151
4152 sep = strchr(str, ':');
4153
4154 if (sep) {
6391a113 4155 for (i = 0; i < ARRAY_SIZE(setup_token); i++) {
1da177e4
LT		 4156 if (!strncmp(setup_token[i].token, str, (sep - str))) {
4157 ret = setup_token[i].val;
4158 break;
4159 }
4160 }
4161 }
4162
4163 return ret;
4164}
4165
2dbb04c6 4166
1da177e4
LT		 4167static struct scsi_host_template qla1280_driver_template = {
4168 .module = THIS_MODULE,
4169 .proc_name = "qla1280",
4170 .name = "Qlogic ISP 1280/12160",
4171 .info = qla1280_info,
4172 .slave_configure = qla1280_slave_configure,
4173 .queuecommand = qla1280_queuecommand,
4174 .eh_abort_handler = qla1280_eh_abort,
4175 .eh_device_reset_handler= qla1280_eh_device_reset,
4176 .eh_bus_reset_handler = qla1280_eh_bus_reset,
4177 .eh_host_reset_handler = qla1280_eh_adapter_reset,
4178 .bios_param = qla1280_biosparam,
2bcbc814 4179 .can_queue = MAX_OUTSTANDING_COMMANDS,
1da177e4
LT		 4180 .this_id = -1,
4181 .sg_tablesize = SG_ALL,
1da177e4 4182};
2dbb04c6 4183
1da177e4 4184
6f039790 4185static int
1da177e4
LT		 4186qla1280_probe_one(struct pci_dev *pdev, const struct pci_device_id *id)
4187{
4188 int devnum = id->driver_data;
4189 struct qla_boards *bdp = &ql1280_board_tbl[devnum];
4190 struct Scsi_Host *host;
4191 struct scsi_qla_host *ha;
4192 int error = -ENODEV;
4193
4194 /* Bypass all AMI SUBSYS VENDOR IDs */
4195 if (pdev->subsystem_vendor == PCI_VENDOR_ID_AMI) {
4196 printk(KERN_INFO
4197 "qla1280: Skipping AMI SubSys Vendor ID Chip\n");
4198 goto error;
4199 }
4200
4201 printk(KERN_INFO "qla1280: %s found on PCI bus %i, dev %i\n",
4202 bdp->name, pdev->bus->number, PCI_SLOT(pdev->devfn));
4203
4204 if (pci_enable_device(pdev)) {
4205 printk(KERN_WARNING
4206 "qla1280: Failed to enabled pci device, aborting.\n");
4207 goto error;
4208 }
4209
4210 pci_set_master(pdev);
4211
4212 error = -ENOMEM;
4213 host = scsi_host_alloc(&qla1280_driver_template, sizeof(*ha));
4214 if (!host) {
4215 printk(KERN_WARNING
4216 "qla1280: Failed to register host, aborting.\n");
4217 goto error_disable_device;
4218 }
4219
4220 ha = (struct scsi_qla_host *)host->hostdata;
4221 memset(ha, 0, sizeof(struct scsi_qla_host));
4222
4223 ha->pdev = pdev;
4224 ha->devnum = devnum; /* specifies microcode load address */
4225
4226#ifdef QLA_64BIT_PTR
4a01ab60 4227 if (dma_set_mask_and_coherent(&ha->pdev->dev, DMA_BIT_MASK(64))) {
60ea4fb1 4228 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
1da177e4 4229 printk(KERN_WARNING "scsi(%li): Unable to set a "
2b55cac3 4230 "suitable DMA mask - aborting\n", ha->host_no);
1da177e4 4231 error = -ENODEV;
eb7a1698 4232 goto error_put_host;
1da177e4
LT		 4233 }
4234 } else
4235 dprintk(2, "scsi(%li): 64 Bit PCI Addressing Enabled\n",
4236 ha->host_no);
4237#else
60ea4fb1 4238 if (dma_set_mask(&ha->pdev->dev, DMA_BIT_MASK(32))) {
1da177e4 4239 printk(KERN_WARNING "scsi(%li): Unable to set a "
2b55cac3 4240 "suitable DMA mask - aborting\n", ha->host_no);
1da177e4 4241 error = -ENODEV;
eb7a1698 4242 goto error_put_host;
1da177e4
LT		 4243 }
4244#endif
4245
60ea4fb1 4246 ha->request_ring = dma_alloc_coherent(&ha->pdev->dev,
2b55cac3 4247 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
60ea4fb1 4248 &ha->request_dma, GFP_KERNEL);
1da177e4
LT		 4249 if (!ha->request_ring) {
4250 printk(KERN_INFO "qla1280: Failed to get request memory\n");
4251 goto error_put_host;
4252 }
4253
60ea4fb1 4254 ha->response_ring = dma_alloc_coherent(&ha->pdev->dev,
2b55cac3 4255 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
60ea4fb1 4256 &ha->response_dma, GFP_KERNEL);
1da177e4
LT		 4257 if (!ha->response_ring) {
4258 printk(KERN_INFO "qla1280: Failed to get response memory\n");
4259 goto error_free_request_ring;
4260 }
4261
4262 ha->ports = bdp->numPorts;
4263
4264 ha->host = host;
4265 ha->host_no = host->host_no;
4266
4267 host->irq = pdev->irq;
4268 host->max_channel = bdp->numPorts - 1;
4269 host->max_lun = MAX_LUNS - 1;
4270 host->max_id = MAX_TARGETS;
4271 host->max_sectors = 1024;
4272 host->unique_id = host->host_no;
4273
1da177e4
LT		 4274 error = -ENODEV;
4275
4276#if MEMORY_MAPPED_IO
25729a7f 4277 ha->mmpbase = pci_ioremap_bar(ha->pdev, 1);
1da177e4
LT		 4278 if (!ha->mmpbase) {
4279 printk(KERN_INFO "qla1280: Unable to map I/O memory\n");
4280 goto error_free_response_ring;
4281 }
4282
4283 host->base = (unsigned long)ha->mmpbase;
4284 ha->iobase = (struct device_reg __iomem *)ha->mmpbase;
4285#else
4286 host->io_port = pci_resource_start(ha->pdev, 0);
4287 if (!request_region(host->io_port, 0xff, "qla1280")) {
4288 printk(KERN_INFO "qla1280: Failed to reserve i/o region "
4289 "0x%04lx-0x%04lx - already in use\n",
4290 host->io_port, host->io_port + 0xff);
4291 goto error_free_response_ring;
4292 }
4293
4294 ha->iobase = (struct device_reg *)host->io_port;
4295#endif
4296
4297 INIT_LIST_HEAD(&ha->done_q);
4298
4299 /* Disable ISP interrupts. */
4300 qla1280_disable_intrs(ha);
4301
1d6f359a 4302 if (request_irq(pdev->irq, qla1280_intr_handler, IRQF_SHARED,
1da177e4
LT		 4303 "qla1280", ha)) {
4304 printk("qla1280 : Failed to reserve interrupt %d already "
4305 "in use\n", pdev->irq);
4306 goto error_release_region;
4307 }
4308
4309 /* load the F/W, read paramaters, and init the H/W */
4310 if (qla1280_initialize_adapter(ha)) {
4311 printk(KERN_INFO "qla1x160: Failed to initialize adapter\n");
4312 goto error_free_irq;
4313 }
4314
4315 /* set our host ID (need to do something about our two IDs) */
4316 host->this_id = ha->bus_settings[0].id;
4317
4318 pci_set_drvdata(pdev, host);
4319
1da177e4
LT		 4320 error = scsi_add_host(host, &pdev->dev);
4321 if (error)
4322 goto error_disable_adapter;
4323 scsi_scan_host(host);
1da177e4
LT		 4324
4325 return 0;
4326
1da177e4 4327 error_disable_adapter:
8af50dcd 4328 qla1280_disable_intrs(ha);
1da177e4
LT		 4329 error_free_irq:
4330 free_irq(pdev->irq, ha);
4331 error_release_region:
4332#if MEMORY_MAPPED_IO
4333 iounmap(ha->mmpbase);
4334#else
4335 release_region(host->io_port, 0xff);
4336#endif
4337 error_free_response_ring:
60ea4fb1 4338 dma_free_coherent(&ha->pdev->dev,
2b55cac3 4339 ((RESPONSE_ENTRY_CNT + 1) * sizeof(struct response)),
1da177e4
LT		 4340 ha->response_ring, ha->response_dma);
4341 error_free_request_ring:
60ea4fb1 4342 dma_free_coherent(&ha->pdev->dev,
2b55cac3 4343 ((REQUEST_ENTRY_CNT + 1) * sizeof(request_t)),
1da177e4
LT		 4344 ha->request_ring, ha->request_dma);
4345 error_put_host:
4346 scsi_host_put(host);
4347 error_disable_device:
4348 pci_disable_device(pdev);
4349 error:
4350 return error;
4351}
4352
4353
6f039790 4354static void
1da177e4
LT		 4355qla1280_remove_one(struct pci_dev *pdev)
4356{
4357 struct Scsi_Host *host = pci_get_drvdata(pdev);
4358 struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
4359
1da177e4 4360 scsi_remove_host(host);
1da177e4 4361
8af50dcd 4362 qla1280_disable_intrs(ha);
1da177e4
LT		 4363
4364 free_irq(pdev->irq, ha);
4365
4366#if MEMORY_MAPPED_IO
4367 iounmap(ha->mmpbase);
4368#else
4369 release_region(host->io_port, 0xff);
4370#endif
4371
60ea4fb1 4372 dma_free_coherent(&ha->pdev->dev,
1da177e4
LT		 4373 ((REQUEST_ENTRY_CNT + 1) * (sizeof(request_t))),
4374 ha->request_ring, ha->request_dma);
60ea4fb1 4375 dma_free_coherent(&ha->pdev->dev,
1da177e4
LT		 4376 ((RESPONSE_ENTRY_CNT + 1) * (sizeof(struct response))),
4377 ha->response_ring, ha->response_dma);
4378
4379 pci_disable_device(pdev);
4380
4381 scsi_host_put(host);
4382}
4383
1da177e4
LT		 4384static struct pci_driver qla1280_pci_driver = {
4385 .name = "qla1280",
4386 .id_table = qla1280_pci_tbl,
4387 .probe = qla1280_probe_one,
6f039790 4388 .remove = qla1280_remove_one,
1da177e4
LT		 4389};
4390
4391static int __init
4392qla1280_init(void)
4393{
4394 if (sizeof(struct srb) > sizeof(struct scsi_pointer)) {
4395 printk(KERN_WARNING
4396 "qla1280: struct srb too big, aborting\n");
4397 return -EINVAL;
4398 }
4399
4400#ifdef MODULE
4401 /*
4402 * If we are called as a module, the qla1280 pointer may not be null
4403 * and it would point to our bootup string, just like on the lilo
4404 * command line. IF not NULL, then process this config string with
4405 * qla1280_setup
4406 *
4407 * Boot time Options
4408 * To add options at boot time add a line to your lilo.conf file like:
4409 * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
4410 * which will result in the first four devices on the first two
4411 * controllers being set to a tagged queue depth of 32.
4412 */
4413 if (qla1280)
4414 qla1280_setup(qla1280);
4415#endif
4416
dcbccbde 4417 return pci_register_driver(&qla1280_pci_driver);
1da177e4
LT		 4418}
4419
4420static void __exit
4421qla1280_exit(void)
4422{
421e33d0
MR		 4423 int i;
4424
1da177e4 4425 pci_unregister_driver(&qla1280_pci_driver);
421e33d0
MR		 4426 /* release any allocated firmware images */
4427 for (i = 0; i < QL_NUM_FW_IMAGES; i++) {
90449e5d
JJ		 4428 release_firmware(qla1280_fw_tbl[i].fw);
4429 qla1280_fw_tbl[i].fw = NULL;
421e33d0 4430 }
1da177e4
LT		 4431}
4432
4433module_init(qla1280_init);
4434module_exit(qla1280_exit);
4435
1da177e4
LT		 4436MODULE_AUTHOR("Qlogic & Jes Sorensen");
4437MODULE_DESCRIPTION("Qlogic ISP SCSI (qla1x80/qla1x160) driver");
4438MODULE_LICENSE("GPL");
1bfa11db
JSR		 4439MODULE_FIRMWARE("qlogic/1040.bin");
4440MODULE_FIRMWARE("qlogic/1280.bin");
4441MODULE_FIRMWARE("qlogic/12160.bin");
1da177e4
LT		 4442MODULE_VERSION(QLA1280_VERSION);
4443
4444/*
4445 * Overrides for Emacs so that we almost follow Linus's tabbing style.
4446 * Emacs will notice this stuff at the end of the file and automatically
4447 * adjust the settings for this buffer only. This must remain at the end
4448 * of the file.
4449 * ---------------------------------------------------------------------------
4450 * Local variables:
4451 * c-basic-offset: 8
4452 * tab-width: 8
4453 * End:
4454 */
Linux 6.x block layer and io_uring tree(s)