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