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