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