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