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