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