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