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