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