Merge master.kernel.org:/pub/scm/linux/kernel/git/jejb/scsi-rc-fixes-2.6
[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.26"
21 /*****************************************************************************
22     Revision History:
23     Rev  3.26, January 16, 2006 Jes Sorensen
24         - Ditch all < 2.6 support
25     Rev  3.25.1, February 10, 2005 Christoph Hellwig
26         - use pci_map_single to map non-S/G requests
27         - remove qla1280_proc_info
28     Rev  3.25, September 28, 2004, Christoph Hellwig
29         - add support for ISP1020/1040
30         - don't include "scsi.h" anymore for 2.6.x
31     Rev  3.24.4 June 7, 2004 Christoph Hellwig
32         - restructure firmware loading, cleanup initialization code
33         - prepare support for ISP1020/1040 chips
34     Rev  3.24.3 January 19, 2004, Jes Sorensen
35         - Handle PCI DMA mask settings correctly
36         - Correct order of error handling in probe_one, free_irq should not
37           be called if request_irq failed
38     Rev  3.24.2 January 19, 2004, James Bottomley & Andrew Vasquez
39         - Big endian fixes (James)
40         - Remove bogus IOCB content on zero data transfer commands (Andrew)
41     Rev  3.24.1 January 5, 2004, Jes Sorensen
42         - Initialize completion queue to avoid OOPS on probe
43         - Handle interrupts during mailbox testing
44     Rev  3.24 November 17, 2003, Christoph Hellwig
45         - use struct list_head for completion queue
46         - avoid old Scsi_FOO typedefs
47         - cleanup 2.4 compat glue a bit
48         - use <scsi/scsi_*.h> headers on 2.6 instead of "scsi.h"
49         - make initialization for memory mapped vs port I/O more similar
50         - remove broken pci config space manipulation
51         - kill more cruft
52         - this is an almost perfect 2.6 scsi driver now! ;)
53     Rev  3.23.39 December 17, 2003, Jes Sorensen
54         - Delete completion queue from srb if mailbox command failed to
55           to avoid qla1280_done completeting qla1280_error_action's
56           obsolete context
57         - Reduce arguments for qla1280_done
58     Rev  3.23.38 October 18, 2003, Christoph Hellwig
59         - Convert to new-style hotplugable driver for 2.6
60         - Fix missing scsi_unregister/scsi_host_put on HBA removal
61         - Kill some more cruft
62     Rev  3.23.37 October 1, 2003, Jes Sorensen
63         - Make MMIO depend on CONFIG_X86_VISWS instead of yet another
64           random CONFIG option
65         - Clean up locking in probe path
66     Rev  3.23.36 October 1, 2003, Christoph Hellwig
67         - queuecommand only ever receives new commands - clear flags
68         - Reintegrate lost fixes from Linux 2.5
69     Rev  3.23.35 August 14, 2003, Jes Sorensen
70         - Build against 2.6
71     Rev  3.23.34 July 23, 2003, Jes Sorensen
72         - Remove pointless TRUE/FALSE macros
73         - Clean up vchan handling
74     Rev  3.23.33 July 3, 2003, Jes Sorensen
75         - Don't define register access macros before define determining MMIO.
76           This just happend to work out on ia64 but not elsewhere.
77         - Don't try and read from the card while it is in reset as
78           it won't respond and causes an MCA
79     Rev  3.23.32 June 23, 2003, Jes Sorensen
80         - Basic support for boot time arguments
81     Rev  3.23.31 June 8, 2003, Jes Sorensen
82         - Reduce boot time messages
83     Rev  3.23.30 June 6, 2003, Jes Sorensen
84         - Do not enable sync/wide/ppr before it has been determined
85           that the target device actually supports it
86         - Enable DMA arbitration for multi channel controllers
87     Rev  3.23.29 June 3, 2003, Jes Sorensen
88         - Port to 2.5.69
89     Rev  3.23.28 June 3, 2003, Jes Sorensen
90         - Eliminate duplicate marker commands on bus resets
91         - Handle outstanding commands appropriately on bus/device resets
92     Rev  3.23.27 May 28, 2003, Jes Sorensen
93         - Remove bogus input queue code, let the Linux SCSI layer do the work
94         - Clean up NVRAM handling, only read it once from the card
95         - Add a number of missing default nvram parameters
96     Rev  3.23.26 Beta May 28, 2003, Jes Sorensen
97         - Use completion queue for mailbox commands instead of busy wait
98     Rev  3.23.25 Beta May 27, 2003, James Bottomley
99         - Migrate to use new error handling code
100     Rev  3.23.24 Beta May 21, 2003, James Bottomley
101         - Big endian support
102         - Cleanup data direction code
103     Rev  3.23.23 Beta May 12, 2003, Jes Sorensen
104         - Switch to using MMIO instead of PIO
105     Rev  3.23.22 Beta April 15, 2003, Jes Sorensen
106         - Fix PCI parity problem with 12160 during reset.
107     Rev  3.23.21 Beta April 14, 2003, Jes Sorensen
108         - Use pci_map_page()/pci_unmap_page() instead of map_single version.
109     Rev  3.23.20 Beta April 9, 2003, Jes Sorensen
110         - Remove < 2.4.x support
111         - Introduce HOST_LOCK to make the spin lock changes portable.
112         - Remove a bunch of idiotic and unnecessary typedef's
113         - Kill all leftovers of target-mode support which never worked anyway
114     Rev  3.23.19 Beta April 11, 2002, Linus Torvalds
115         - Do qla1280_pci_config() before calling request_irq() and
116           request_region()
117         - Use pci_dma_hi32() to handle upper word of DMA addresses instead
118           of large shifts
119         - Hand correct arguments to free_irq() in case of failure
120     Rev  3.23.18 Beta April 11, 2002, Jes Sorensen
121         - Run source through Lindent and clean up the output
122     Rev  3.23.17 Beta April 11, 2002, Jes Sorensen
123         - Update SCSI firmware to qla1280 v8.15.00 and qla12160 v10.04.32
124     Rev  3.23.16 Beta March 19, 2002, Jes Sorensen
125         - Rely on mailbox commands generating interrupts - do not
126           run qla1280_isr() from ql1280_mailbox_command()
127         - Remove device_reg_t
128         - Integrate ql12160_set_target_parameters() with 1280 version
129         - Make qla1280_setup() non static
130         - Do not call qla1280_check_for_dead_scsi_bus() on every I/O request
131           sent to the card - this command pauses the firmare!!!
132     Rev  3.23.15 Beta March 19, 2002, Jes Sorensen
133         - Clean up qla1280.h - remove obsolete QL_DEBUG_LEVEL_x definitions
134         - Remove a pile of pointless and confusing (srb_t **) and
135           (scsi_lu_t *) typecasts
136         - Explicit mark that we do not use the new error handling (for now)
137         - Remove scsi_qla_host_t and use 'struct' instead
138         - Remove in_abort, watchdog_enabled, dpc, dpc_sched, bios_enabled,
139           pci_64bit_slot flags which weren't used for anything anyway
140         - Grab host->host_lock while calling qla1280_isr() from abort()
141         - Use spin_lock()/spin_unlock() in qla1280_intr_handler() - we
142           do not need to save/restore flags in the interrupt handler
143         - Enable interrupts early (before any mailbox access) in preparation
144           for cleaning up the mailbox handling
145     Rev  3.23.14 Beta March 14, 2002, Jes Sorensen
146         - Further cleanups. Remove all trace of QL_DEBUG_LEVEL_x and replace
147           it with proper use of dprintk().
148         - Make qla1280_print_scsi_cmd() and qla1280_dump_buffer() both take
149           a debug level argument to determine if data is to be printed
150         - Add KERN_* info to printk()
151     Rev  3.23.13 Beta March 14, 2002, Jes Sorensen
152         - Significant cosmetic cleanups
153         - Change debug code to use dprintk() and remove #if mess
154     Rev  3.23.12 Beta March 13, 2002, Jes Sorensen
155         - More cosmetic cleanups, fix places treating return as function
156         - use cpu_relax() in qla1280_debounce_register()
157     Rev  3.23.11 Beta March 13, 2002, Jes Sorensen
158         - Make it compile under 2.5.5
159     Rev  3.23.10 Beta October 1, 2001, Jes Sorensen
160         - Do no typecast short * to long * in QL1280BoardTbl, this
161           broke miserably on big endian boxes
162     Rev  3.23.9 Beta September 30, 2001, Jes Sorensen
163         - Remove pre 2.2 hack for checking for reentrance in interrupt handler
164         - Make data types used to receive from SCSI_{BUS,TCN,LUN}_32
165           unsigned int to match the types from struct scsi_cmnd
166     Rev  3.23.8 Beta September 29, 2001, Jes Sorensen
167         - Remove bogus timer_t typedef from qla1280.h
168         - Remove obsolete pre 2.2 PCI setup code, use proper #define's
169           for PCI_ values, call pci_set_master()
170         - Fix memleak of qla1280_buffer on module unload
171         - Only compile module parsing code #ifdef MODULE - should be
172           changed to use individual MODULE_PARM's later
173         - Remove dummy_buffer that was never modified nor printed
174         - ENTER()/LEAVE() are noops unless QL_DEBUG_LEVEL_3, hence remove
175           #ifdef QL_DEBUG_LEVEL_3/#endif around ENTER()/LEAVE() calls
176         - Remove \r from print statements, this is Linux, not DOS
177         - Remove obsolete QLA1280_{SCSILU,INTR,RING}_{LOCK,UNLOCK}
178           dummy macros
179         - Remove C++ compile hack in header file as Linux driver are not
180           supposed to be compiled as C++
181         - Kill MS_64BITS macro as it makes the code more readable
182         - Remove unnecessary flags.in_interrupts bit
183     Rev  3.23.7 Beta August 20, 2001, Jes Sorensen
184         - Dont' check for set flags on q->q_flag one by one in qla1280_next()
185         - Check whether the interrupt was generated by the QLA1280 before
186           doing any processing
187         - qla1280_status_entry(): Only zero out part of sense_buffer that
188           is not being copied into
189         - Remove more superflouous typecasts
190         - qla1280_32bit_start_scsi() replace home-brew memcpy() with memcpy()
191     Rev  3.23.6 Beta August 20, 2001, Tony Luck, Intel
192         - Don't walk the entire list in qla1280_putq_t() just to directly
193           grab the pointer to the last element afterwards
194     Rev  3.23.5 Beta August 9, 2001, Jes Sorensen
195         - Don't use SA_INTERRUPT, it's use is deprecated for this kinda driver
196     Rev  3.23.4 Beta August 8, 2001, Jes Sorensen
197         - Set dev->max_sectors to 1024
198     Rev  3.23.3 Beta August 6, 2001, Jes Sorensen
199         - Provide compat macros for pci_enable_device(), pci_find_subsys()
200           and scsi_set_pci_device()
201         - Call scsi_set_pci_device() for all devices
202         - Reduce size of kernel version dependent device probe code
203         - Move duplicate probe/init code to separate function
204         - Handle error if qla1280_mem_alloc() fails
205         - Kill OFFSET() macro and use Linux's PCI definitions instead
206         - Kill private structure defining PCI config space (struct config_reg)
207         - Only allocate I/O port region if not in MMIO mode
208         - Remove duplicate (unused) sanity check of sife of srb_t
209     Rev  3.23.2 Beta August 6, 2001, Jes Sorensen
210         - Change home-brew memset() implementations to use memset()
211         - Remove all references to COMTRACE() - accessing a PC's COM2 serial
212           port directly is not legal under Linux.
213     Rev  3.23.1 Beta April 24, 2001, Jes Sorensen
214         - Remove pre 2.2 kernel support
215         - clean up 64 bit DMA setting to use 2.4 API (provide backwards compat)
216         - Fix MMIO access to use readl/writel instead of directly
217           dereferencing pointers
218         - Nuke MSDOS debugging code
219         - Change true/false data types to int from uint8_t
220         - Use int for counters instead of uint8_t etc.
221         - Clean up size & byte order conversion macro usage
222     Rev  3.23 Beta January 11, 2001 BN Qlogic
223         - Added check of device_id when handling non
224           QLA12160s during detect().
225     Rev  3.22 Beta January 5, 2001 BN Qlogic
226         - Changed queue_task() to schedule_task()
227           for kernels 2.4.0 and higher.
228           Note: 2.4.0-testxx kernels released prior to
229                 the actual 2.4.0 kernel release on January 2001
230                 will get compile/link errors with schedule_task().
231                 Please update your kernel to released 2.4.0 level,
232                 or comment lines in this file flagged with  3.22
233                 to resolve compile/link error of schedule_task().
234         - Added -DCONFIG_SMP in addition to -D__SMP__
235           in Makefile for 2.4.0 builds of driver as module.
236     Rev  3.21 Beta January 4, 2001 BN Qlogic
237         - Changed criteria of 64/32 Bit mode of HBA
238           operation according to BITS_PER_LONG rather
239           than HBA's NVRAM setting of >4Gig memory bit;
240           so that the HBA auto-configures without the need
241           to setup each system individually.
242     Rev  3.20 Beta December 5, 2000 BN Qlogic
243         - Added priority handling to IA-64  onboard SCSI
244           ISP12160 chip for kernels greater than 2.3.18.
245         - Added irqrestore for qla1280_intr_handler.
246         - Enabled /proc/scsi/qla1280 interface.
247         - Clear /proc/scsi/qla1280 counters in detect().
248     Rev  3.19 Beta October 13, 2000 BN Qlogic
249         - Declare driver_template for new kernel
250           (2.4.0 and greater) scsi initialization scheme.
251         - Update /proc/scsi entry for 2.3.18 kernels and
252           above as qla1280
253     Rev  3.18 Beta October 10, 2000 BN Qlogic
254         - Changed scan order of adapters to map
255           the QLA12160 followed by the QLA1280.
256     Rev  3.17 Beta September 18, 2000 BN Qlogic
257         - Removed warnings for 32 bit 2.4.x compiles
258         - Corrected declared size for request and response
259           DMA addresses that are kept in each ha
260     Rev. 3.16 Beta  August 25, 2000   BN  Qlogic
261         - Corrected 64 bit addressing issue on IA-64
262           where the upper 32 bits were not properly
263           passed to the RISC engine.
264     Rev. 3.15 Beta  August 22, 2000   BN  Qlogic
265         - Modified qla1280_setup_chip to properly load
266           ISP firmware for greater that 4 Gig memory on IA-64
267     Rev. 3.14 Beta  August 16, 2000   BN  Qlogic
268         - Added setting of dma_mask to full 64 bit
269           if flags.enable_64bit_addressing is set in NVRAM
270     Rev. 3.13 Beta  August 16, 2000   BN  Qlogic
271         - Use new PCI DMA mapping APIs for 2.4.x kernel
272     Rev. 3.12       July 18, 2000    Redhat & BN Qlogic
273         - Added check of pci_enable_device to detect() for 2.3.x
274         - Use pci_resource_start() instead of
275           pdev->resource[0].start in detect() for 2.3.x
276         - Updated driver version
277     Rev. 3.11       July 14, 2000    BN  Qlogic
278         - Updated SCSI Firmware to following versions:
279           qla1x80:   8.13.08
280           qla1x160:  10.04.08
281         - Updated driver version to 3.11
282     Rev. 3.10    June 23, 2000   BN Qlogic
283         - Added filtering of AMI SubSys Vendor ID devices
284     Rev. 3.9
285         - DEBUG_QLA1280 undefined and  new version  BN Qlogic
286     Rev. 3.08b      May 9, 2000    MD Dell
287         - Added logic to check against AMI subsystem vendor ID
288         Rev. 3.08       May 4, 2000    DG  Qlogic
289         - Added logic to check for PCI subsystem ID.
290         Rev. 3.07       Apr 24, 2000    DG & BN  Qlogic
291            - Updated SCSI Firmware to following versions:
292              qla12160:   10.01.19
293                  qla1280:     8.09.00
294         Rev. 3.06       Apr 12, 2000    DG & BN  Qlogic
295            - Internal revision; not released
296     Rev. 3.05       Mar 28, 2000    DG & BN  Qlogic
297        - Edit correction for virt_to_bus and PROC.
298     Rev. 3.04       Mar 28, 2000    DG & BN  Qlogic
299        - Merge changes from ia64 port.
300     Rev. 3.03       Mar 28, 2000    BN  Qlogic
301        - Increase version to reflect new code drop with compile fix
302          of issue with inclusion of linux/spinlock for 2.3 kernels
303     Rev. 3.02       Mar 15, 2000    BN  Qlogic
304        - Merge qla1280_proc_info from 2.10 code base
305     Rev. 3.01       Feb 10, 2000    BN  Qlogic
306        - Corrected code to compile on a 2.2.x kernel.
307     Rev. 3.00       Jan 17, 2000    DG  Qlogic
308            - Added 64-bit support.
309     Rev. 2.07       Nov 9, 1999     DG  Qlogic
310            - Added new routine to set target parameters for ISP12160.
311     Rev. 2.06       Sept 10, 1999     DG  Qlogic
312        - Added support for ISP12160 Ultra 3 chip.
313     Rev. 2.03       August 3, 1999    Fred Lewis, Intel DuPont
314         - Modified code to remove errors generated when compiling with
315           Cygnus IA64 Compiler.
316         - Changed conversion of pointers to unsigned longs instead of integers.
317         - Changed type of I/O port variables from uint32_t to unsigned long.
318         - Modified OFFSET macro to work with 64-bit as well as 32-bit.
319         - Changed sprintf and printk format specifiers for pointers to %p.
320         - Changed some int to long type casts where needed in sprintf & printk.
321         - Added l modifiers to sprintf and printk format specifiers for longs.
322         - Removed unused local variables.
323     Rev. 1.20       June 8, 1999      DG,  Qlogic
324          Changes to support RedHat release 6.0 (kernel 2.2.5).
325        - Added SCSI exclusive access lock (io_request_lock) when accessing
326          the adapter.
327        - Added changes for the new LINUX interface template. Some new error
328          handling routines have been added to the template, but for now we
329          will use the old ones.
330     -   Initial Beta Release.
331 *****************************************************************************/
332
333
334 #include <linux/config.h>
335 #include <linux/module.h>
336
337 #include <linux/version.h>
338 #include <linux/types.h>
339 #include <linux/string.h>
340 #include <linux/errno.h>
341 #include <linux/kernel.h>
342 #include <linux/ioport.h>
343 #include <linux/delay.h>
344 #include <linux/timer.h>
345 #include <linux/sched.h>
346 #include <linux/pci.h>
347 #include <linux/proc_fs.h>
348 #include <linux/stat.h>
349 #include <linux/slab.h>
350 #include <linux/pci_ids.h>
351 #include <linux/interrupt.h>
352 #include <linux/init.h>
353
354 #include <asm/io.h>
355 #include <asm/irq.h>
356 #include <asm/byteorder.h>
357 #include <asm/processor.h>
358 #include <asm/types.h>
359 #include <asm/system.h>
360
361 #include <scsi/scsi.h>
362 #include <scsi/scsi_cmnd.h>
363 #include <scsi/scsi_device.h>
364 #include <scsi/scsi_host.h>
365 #include <scsi/scsi_tcq.h>
366
367 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
368 #include <asm/sn/io.h>
369 #endif
370
371 #if LINUX_VERSION_CODE < 0x020600
372 #error "Kernels older than 2.6.0 are no longer supported"
373 #endif
374
375
376 /*
377  * Compile time Options:
378  *            0 - Disable and 1 - Enable
379  */
380 #define  DEBUG_QLA1280_INTR     0
381 #define  DEBUG_PRINT_NVRAM      0
382 #define  DEBUG_QLA1280          0
383
384 /*
385  * The SGI VISWS is broken and doesn't support MMIO ;-(
386  */
387 #ifdef CONFIG_X86_VISWS
388 #define MEMORY_MAPPED_IO        0
389 #else
390 #define MEMORY_MAPPED_IO        1
391 #endif
392
393 #define UNIQUE_FW_NAME
394 #include "qla1280.h"
395 #include "ql12160_fw.h"         /* ISP RISC codes */
396 #include "ql1280_fw.h"
397 #include "ql1040_fw.h"
398
399
400 /*
401  * Missing PCI ID's
402  */
403 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1080
404 #define PCI_DEVICE_ID_QLOGIC_ISP1080    0x1080
405 #endif
406 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1240
407 #define PCI_DEVICE_ID_QLOGIC_ISP1240    0x1240
408 #endif
409 #ifndef PCI_DEVICE_ID_QLOGIC_ISP1280
410 #define PCI_DEVICE_ID_QLOGIC_ISP1280    0x1280
411 #endif
412 #ifndef PCI_DEVICE_ID_QLOGIC_ISP10160
413 #define PCI_DEVICE_ID_QLOGIC_ISP10160   0x1016
414 #endif
415 #ifndef PCI_DEVICE_ID_QLOGIC_ISP12160
416 #define PCI_DEVICE_ID_QLOGIC_ISP12160   0x1216
417 #endif
418
419 #ifndef PCI_VENDOR_ID_AMI
420 #define PCI_VENDOR_ID_AMI               0x101e
421 #endif
422
423 #ifndef BITS_PER_LONG
424 #error "BITS_PER_LONG not defined!"
425 #endif
426 #if (BITS_PER_LONG == 64) || defined CONFIG_HIGHMEM
427 #define QLA_64BIT_PTR   1
428 #endif
429
430 #ifdef QLA_64BIT_PTR
431 #define pci_dma_hi32(a)                 ((a >> 16) >> 16)
432 #else
433 #define pci_dma_hi32(a)                 0
434 #endif
435 #define pci_dma_lo32(a)                 (a & 0xffffffff)
436
437 #define NVRAM_DELAY()                   udelay(500)     /* 2 microseconds */
438
439 #if defined(__ia64__) && !defined(ia64_platform_is)
440 #define ia64_platform_is(foo)           (!strcmp(x, platform_name))
441 #endif
442
443
444 #define IS_ISP1040(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020)
445 #define IS_ISP1x40(ha) (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1020 || \
446                         ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP1240)
447 #define IS_ISP1x160(ha)        (ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP10160 || \
448                                 ha->pdev->device == PCI_DEVICE_ID_QLOGIC_ISP12160)
449
450
451 static int qla1280_probe_one(struct pci_dev *, const struct pci_device_id *);
452 static void qla1280_remove_one(struct pci_dev *);
453
454 /*
455  *  QLogic Driver Support Function Prototypes.
456  */
457 static void qla1280_done(struct scsi_qla_host *);
458 static int qla1280_get_token(char *);
459 static int qla1280_setup(char *s) __init;
460
461 /*
462  *  QLogic ISP1280 Hardware Support Function Prototypes.
463  */
464 static int qla1280_load_firmware(struct scsi_qla_host *);
465 static int qla1280_init_rings(struct scsi_qla_host *);
466 static int qla1280_nvram_config(struct scsi_qla_host *);
467 static int qla1280_mailbox_command(struct scsi_qla_host *,
468                                    uint8_t, uint16_t *);
469 static int qla1280_bus_reset(struct scsi_qla_host *, int);
470 static int qla1280_device_reset(struct scsi_qla_host *, int, int);
471 static int qla1280_abort_device(struct scsi_qla_host *, int, int, int);
472 static int qla1280_abort_command(struct scsi_qla_host *, struct srb *, int);
473 static int qla1280_abort_isp(struct scsi_qla_host *);
474 #ifdef QLA_64BIT_PTR
475 static int qla1280_64bit_start_scsi(struct scsi_qla_host *, struct srb *);
476 #else
477 static int qla1280_32bit_start_scsi(struct scsi_qla_host *, struct srb *);
478 #endif
479 static void qla1280_nv_write(struct scsi_qla_host *, uint16_t);
480 static void qla1280_poll(struct scsi_qla_host *);
481 static void qla1280_reset_adapter(struct scsi_qla_host *);
482 static void qla1280_marker(struct scsi_qla_host *, int, int, int, u8);
483 static void qla1280_isp_cmd(struct scsi_qla_host *);
484 static void qla1280_isr(struct scsi_qla_host *, struct list_head *);
485 static void qla1280_rst_aen(struct scsi_qla_host *);
486 static void qla1280_status_entry(struct scsi_qla_host *, struct response *,
487                                  struct list_head *);
488 static void qla1280_error_entry(struct scsi_qla_host *, struct response *,
489                                 struct list_head *);
490 static uint16_t qla1280_get_nvram_word(struct scsi_qla_host *, uint32_t);
491 static uint16_t qla1280_nvram_request(struct scsi_qla_host *, uint32_t);
492 static uint16_t qla1280_debounce_register(volatile uint16_t __iomem *);
493 static request_t *qla1280_req_pkt(struct scsi_qla_host *);
494 static int qla1280_check_for_dead_scsi_bus(struct scsi_qla_host *,
495                                            unsigned int);
496 static void qla1280_get_target_parameters(struct scsi_qla_host *,
497                                            struct scsi_device *);
498 static int qla1280_set_target_parameters(struct scsi_qla_host *, int, int);
499
500
501 static struct qla_driver_setup driver_setup;
502
503 /*
504  * convert scsi data direction to request_t control flags
505  */
506 static inline uint16_t
507 qla1280_data_direction(struct scsi_cmnd *cmnd)
508 {
509         switch(cmnd->sc_data_direction) {
510         case DMA_FROM_DEVICE:
511                 return BIT_5;
512         case DMA_TO_DEVICE:
513                 return BIT_6;
514         case DMA_BIDIRECTIONAL:
515                 return BIT_5 | BIT_6;
516         /*
517          * We could BUG() on default here if one of the four cases aren't
518          * met, but then again if we receive something like that from the
519          * SCSI layer we have more serious problems. This shuts up GCC.
520          */
521         case DMA_NONE:
522         default:
523                 return 0;
524         }
525 }
526                 
527 #if DEBUG_QLA1280
528 static void __qla1280_print_scsi_cmd(struct scsi_cmnd * cmd);
529 static void __qla1280_dump_buffer(char *, int);
530 #endif
531
532
533 /*
534  * insmod needs to find the variable and make it point to something
535  */
536 #ifdef MODULE
537 static char *qla1280;
538
539 /* insmod qla1280 options=verbose" */
540 module_param(qla1280, charp, 0);
541 #else
542 __setup("qla1280=", qla1280_setup);
543 #endif
544
545
546 /*
547  * We use the scsi_pointer structure that's included with each scsi_command
548  * to overlay our struct srb over it. qla1280_init() checks that a srb is not
549  * bigger than a scsi_pointer.
550  */
551
552 #define CMD_SP(Cmnd)            &Cmnd->SCp
553 #define CMD_CDBLEN(Cmnd)        Cmnd->cmd_len
554 #define CMD_CDBP(Cmnd)          Cmnd->cmnd
555 #define CMD_SNSP(Cmnd)          Cmnd->sense_buffer
556 #define CMD_SNSLEN(Cmnd)        sizeof(Cmnd->sense_buffer)
557 #define CMD_RESULT(Cmnd)        Cmnd->result
558 #define CMD_HANDLE(Cmnd)        Cmnd->host_scribble
559 #define CMD_REQUEST(Cmnd)       Cmnd->request->cmd
560
561 #define CMD_HOST(Cmnd)          Cmnd->device->host
562 #define SCSI_BUS_32(Cmnd)       Cmnd->device->channel
563 #define SCSI_TCN_32(Cmnd)       Cmnd->device->id
564 #define SCSI_LUN_32(Cmnd)       Cmnd->device->lun
565
566
567 /*****************************************/
568 /*   ISP Boards supported by this driver */
569 /*****************************************/
570
571 struct qla_boards {
572         unsigned char name[9];  /* Board ID String */
573         int numPorts;           /* Number of SCSI ports */
574         unsigned short *fwcode; /* pointer to FW array         */
575         unsigned short *fwlen;  /* number of words in array    */
576         unsigned short *fwstart;        /* start address for F/W       */
577         unsigned char *fwver;   /* Ptr to F/W version array    */
578 };
579
580 /* NOTE: the last argument in each entry is used to index ql1280_board_tbl */
581 static struct pci_device_id qla1280_pci_tbl[] = {
582         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP12160,
583                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 0},
584         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1020,
585                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 1},
586         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1080,
587                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 2},
588         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1240,
589                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 3},
590         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP1280,
591                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 4},
592         {PCI_VENDOR_ID_QLOGIC, PCI_DEVICE_ID_QLOGIC_ISP10160,
593                 PCI_ANY_ID, PCI_ANY_ID, 0, 0, 5},
594         {0,}
595 };
596 MODULE_DEVICE_TABLE(pci, qla1280_pci_tbl);
597
598 static struct qla_boards ql1280_board_tbl[] = {
599         /* Name ,  Number of ports, FW details */
600         {"QLA12160", 2, &fw12160i_code01[0], &fw12160i_length01,
601          &fw12160i_addr01, &fw12160i_version_str[0]},
602         {"QLA1040", 1, &risc_code01[0], &risc_code_length01,
603          &risc_code_addr01, &firmware_version[0]},
604         {"QLA1080", 1, &fw1280ei_code01[0], &fw1280ei_length01,
605          &fw1280ei_addr01, &fw1280ei_version_str[0]},
606         {"QLA1240", 2, &fw1280ei_code01[0], &fw1280ei_length01,
607          &fw1280ei_addr01, &fw1280ei_version_str[0]},
608         {"QLA1280", 2, &fw1280ei_code01[0], &fw1280ei_length01,
609          &fw1280ei_addr01, &fw1280ei_version_str[0]},
610         {"QLA10160", 1, &fw12160i_code01[0], &fw12160i_length01,
611          &fw12160i_addr01, &fw12160i_version_str[0]},
612         {"        ", 0}
613 };
614
615 static int qla1280_verbose = 1;
616
617 #if DEBUG_QLA1280
618 static int ql_debug_level = 1;
619 #define dprintk(level, format, a...)    \
620         do { if (ql_debug_level >= level) printk(KERN_ERR format, ##a); } while(0)
621 #define qla1280_dump_buffer(level, buf, size)   \
622         if (ql_debug_level >= level) __qla1280_dump_buffer(buf, size)
623 #define qla1280_print_scsi_cmd(level, cmd)      \
624         if (ql_debug_level >= level) __qla1280_print_scsi_cmd(cmd)
625 #else
626 #define ql_debug_level                  0
627 #define dprintk(level, format, a...)    do{}while(0)
628 #define qla1280_dump_buffer(a, b, c)    do{}while(0)
629 #define qla1280_print_scsi_cmd(a, b)    do{}while(0)
630 #endif
631
632 #define ENTER(x)                dprintk(3, "qla1280 : Entering %s()\n", x);
633 #define LEAVE(x)                dprintk(3, "qla1280 : Leaving %s()\n", x);
634 #define ENTER_INTR(x)           dprintk(4, "qla1280 : Entering %s()\n", x);
635 #define LEAVE_INTR(x)           dprintk(4, "qla1280 : Leaving %s()\n", x);
636
637
638 static int qla1280_read_nvram(struct scsi_qla_host *ha)
639 {
640         uint16_t *wptr;
641         uint8_t chksum;
642         int cnt, i;
643         struct nvram *nv;
644
645         ENTER("qla1280_read_nvram");
646
647         if (driver_setup.no_nvram)
648                 return 1;
649
650         printk(KERN_INFO "scsi(%ld): Reading NVRAM\n", ha->host_no);
651
652         wptr = (uint16_t *)&ha->nvram;
653         nv = &ha->nvram;
654         chksum = 0;
655         for (cnt = 0; cnt < 3; cnt++) {
656                 *wptr = qla1280_get_nvram_word(ha, cnt);
657                 chksum += *wptr & 0xff;
658                 chksum += (*wptr >> 8) & 0xff;
659                 wptr++;
660         }
661
662         if (nv->id0 != 'I' || nv->id1 != 'S' ||
663             nv->id2 != 'P' || nv->id3 != ' ' || nv->version < 1) {
664                 dprintk(2, "Invalid nvram ID or version!\n");
665                 chksum = 1;
666         } else {
667                 for (; cnt < sizeof(struct nvram); cnt++) {
668                         *wptr = qla1280_get_nvram_word(ha, cnt);
669                         chksum += *wptr & 0xff;
670                         chksum += (*wptr >> 8) & 0xff;
671                         wptr++;
672                 }
673         }
674
675         dprintk(3, "qla1280_read_nvram: NVRAM Magic ID= %c %c %c %02x"
676                " version %i\n", nv->id0, nv->id1, nv->id2, nv->id3,
677                nv->version);
678
679
680         if (chksum) {
681                 if (!driver_setup.no_nvram)
682                         printk(KERN_WARNING "scsi(%ld): Unable to identify or "
683                                "validate NVRAM checksum, using default "
684                                "settings\n", ha->host_no);
685                 ha->nvram_valid = 0;
686         } else
687                 ha->nvram_valid = 1;
688
689         /* The firmware interface is, um, interesting, in that the
690          * actual firmware image on the chip is little endian, thus,
691          * the process of taking that image to the CPU would end up
692          * little endian.  However, the firmare interface requires it
693          * to be read a word (two bytes) at a time.
694          *
695          * The net result of this would be that the word (and
696          * doubleword) quantites in the firmware would be correct, but
697          * the bytes would be pairwise reversed.  Since most of the
698          * firmware quantites are, in fact, bytes, we do an extra
699          * le16_to_cpu() in the firmware read routine.
700          *
701          * The upshot of all this is that the bytes in the firmware
702          * are in the correct places, but the 16 and 32 bit quantites
703          * are still in little endian format.  We fix that up below by
704          * doing extra reverses on them */
705         nv->isp_parameter = cpu_to_le16(nv->isp_parameter);
706         nv->firmware_feature.w = cpu_to_le16(nv->firmware_feature.w);
707         for(i = 0; i < MAX_BUSES; i++) {
708                 nv->bus[i].selection_timeout = cpu_to_le16(nv->bus[i].selection_timeout);
709                 nv->bus[i].max_queue_depth = cpu_to_le16(nv->bus[i].max_queue_depth);
710         }
711         dprintk(1, "qla1280_read_nvram: Completed Reading NVRAM\n");
712         LEAVE("qla1280_read_nvram");
713
714         return chksum;
715 }
716
717 /**************************************************************************
718  *   qla1280_info
719  *     Return a string describing the driver.
720  **************************************************************************/
721 static const char *
722 qla1280_info(struct Scsi_Host *host)
723 {
724         static char qla1280_scsi_name_buffer[125];
725         char *bp;
726         struct scsi_qla_host *ha;
727         struct qla_boards *bdp;
728
729         bp = &qla1280_scsi_name_buffer[0];
730         ha = (struct scsi_qla_host *)host->hostdata;
731         bdp = &ql1280_board_tbl[ha->devnum];
732         memset(bp, 0, sizeof(qla1280_scsi_name_buffer));
733
734         sprintf (bp,
735                  "QLogic %s PCI to SCSI Host Adapter\n"
736                  "       Firmware version: %2d.%02d.%02d, Driver version %s",
737                  &bdp->name[0], bdp->fwver[0], bdp->fwver[1], bdp->fwver[2],
738                  QLA1280_VERSION);
739         return bp;
740 }
741
742 /**************************************************************************
743  *   qla1200_queuecommand
744  *     Queue a command to the controller.
745  *
746  * Note:
747  * The mid-level driver tries to ensures that queuecommand never gets invoked
748  * concurrently with itself or the interrupt handler (although the
749  * interrupt handler may call this routine as part of request-completion
750  * handling).   Unfortunely, it sometimes calls the scheduler in interrupt
751  * context which is a big NO! NO!.
752  **************************************************************************/
753 static int
754 qla1280_queuecommand(struct scsi_cmnd *cmd, void (*fn)(struct scsi_cmnd *))
755 {
756         struct Scsi_Host *host = cmd->device->host;
757         struct scsi_qla_host *ha = (struct scsi_qla_host *)host->hostdata;
758         struct srb *sp = (struct srb *)&cmd->SCp;
759         int status;
760
761         cmd->scsi_done = fn;
762         sp->cmd = cmd;
763         sp->flags = 0;
764
765         qla1280_print_scsi_cmd(5, cmd);
766
767 #ifdef QLA_64BIT_PTR
768         /*
769          * Using 64 bit commands if the PCI bridge doesn't support it is a
770          * bit wasteful, however this should really only happen if one's
771          * PCI controller is completely broken, like the BCM1250. For
772          * sane hardware this is not an issue.
773          */
774         status = qla1280_64bit_start_scsi(ha, sp);
775 #else
776         status = qla1280_32bit_start_scsi(ha, sp);
777 #endif
778         return status;
779 }
780
781 enum action {
782         ABORT_COMMAND,
783         ABORT_DEVICE,
784         DEVICE_RESET,
785         BUS_RESET,
786         ADAPTER_RESET,
787         FAIL
788 };
789
790 /* timer action for error action processor */
791 static void qla1280_error_wait_timeout(unsigned long __data)
792 {
793         struct scsi_cmnd *cmd = (struct scsi_cmnd *)__data;
794         struct srb *sp = (struct srb *)CMD_SP(cmd);
795
796         complete(sp->wait);
797 }
798
799 static void qla1280_mailbox_timeout(unsigned long __data)
800 {
801         struct scsi_qla_host *ha = (struct scsi_qla_host *)__data;
802         struct device_reg __iomem *reg;
803         reg = ha->iobase;
804
805         ha->mailbox_out[0] = RD_REG_WORD(&reg->mailbox0);
806         printk(KERN_ERR "scsi(%ld): mailbox timed out, mailbox0 %04x, "
807                "ictrl %04x, istatus %04x\n", ha->host_no, ha->mailbox_out[0],
808                RD_REG_WORD(&reg->ictrl), RD_REG_WORD(&reg->istatus));
809         complete(ha->mailbox_wait);
810 }
811
812 /**************************************************************************
813  * qla1200_error_action
814  *    The function will attempt to perform a specified error action and
815  *    wait for the results (or time out).
816  *
817  * Input:
818  *      cmd = Linux SCSI command packet of the command that cause the
819  *            bus reset.
820  *      action = error action to take (see action_t)
821  *
822  * Returns:
823  *      SUCCESS or FAILED
824  *
825  * Note:
826  *      Resetting the bus always succeeds - is has to, otherwise the
827  *      kernel will panic! Try a surgical technique - sending a BUS
828  *      DEVICE RESET message - on the offending target before pulling
829  *      the SCSI bus reset line.
830  **************************************************************************/
831 static int
832 qla1280_error_action(struct scsi_cmnd *cmd, enum action action)
833 {
834         struct scsi_qla_host *ha;
835         int bus, target, lun;
836         struct srb *sp;
837         uint16_t data;
838         unsigned char *handle;
839         int result, i;
840         DECLARE_COMPLETION(wait);
841         struct timer_list timer;
842
843         ha = (struct scsi_qla_host *)(CMD_HOST(cmd)->hostdata);
844
845         dprintk(4, "error_action %i, istatus 0x%04x\n", action,
846                 RD_REG_WORD(&ha->iobase->istatus));
847
848         dprintk(4, "host_cmd 0x%04x, ictrl 0x%04x, jiffies %li\n",
849                 RD_REG_WORD(&ha->iobase->host_cmd),
850                 RD_REG_WORD(&ha->iobase->ictrl), jiffies);
851
852         ENTER("qla1280_error_action");
853         if (qla1280_verbose)
854                 printk(KERN_INFO "scsi(%li): Resetting Cmnd=0x%p, "
855                        "Handle=0x%p, action=0x%x\n",
856                        ha->host_no, cmd, CMD_HANDLE(cmd), action);
857
858         if (cmd == NULL) {
859                 printk(KERN_WARNING "(scsi?:?:?:?) Reset called with NULL "
860                        "si_Cmnd pointer, failing.\n");
861                 LEAVE("qla1280_error_action");
862                 return FAILED;
863         }
864
865         ha = (struct scsi_qla_host *)cmd->device->host->hostdata;
866         sp = (struct srb *)CMD_SP(cmd);
867         handle = CMD_HANDLE(cmd);
868
869         /* Check for pending interrupts. */
870         data = qla1280_debounce_register(&ha->iobase->istatus);
871         /*
872          * The io_request_lock is held when the reset handler is called, hence
873          * the interrupt handler cannot be running in parallel as it also
874          * grabs the lock. /Jes
875          */
876         if (data & RISC_INT)
877                 qla1280_isr(ha, &ha->done_q);
878
879         /*
880          * Determine the suggested action that the mid-level driver wants
881          * us to perform.
882          */
883         if (handle == (unsigned char *)INVALID_HANDLE || handle == NULL) {
884                 if(action == ABORT_COMMAND) {
885                         /* we never got this command */
886                         printk(KERN_INFO "qla1280: Aborting a NULL handle\n");
887                         return SUCCESS; /* no action - we don't have command */
888                 }
889         } else {
890                 sp->wait = &wait;
891         }
892
893         bus = SCSI_BUS_32(cmd);
894         target = SCSI_TCN_32(cmd);
895         lun = SCSI_LUN_32(cmd);
896
897         /* Overloading result.  Here it means the success or fail of the
898          * *issue* of the action.  When we return from the routine, it must
899          * mean the actual success or fail of the action */
900         result = FAILED;
901         switch (action) {
902         case FAIL:
903                 break;
904
905         case ABORT_COMMAND:
906                 if ((sp->flags & SRB_ABORT_PENDING)) {
907                         printk(KERN_WARNING
908                                "scsi(): Command has a pending abort "
909                                "message - ABORT_PENDING.\n");
910                         /* This should technically be impossible since we
911                          * now wait for abort completion */
912                         break;
913                 }
914
915                 for (i = 0; i < MAX_OUTSTANDING_COMMANDS; i++) {
916                         if (sp == ha->outstanding_cmds[i]) {
917                                 dprintk(1, "qla1280: RISC aborting command\n");
918                                 if (qla1280_abort_command(ha, sp, i) == 0)
919                                         result = SUCCESS;
920                                 else {
921                                         /*
922                                          * Since we don't know what might
923                                          * have happend to the command, it
924                                          * is unsafe to remove it from the
925                                          * device's queue at this point.
926                                          * Wait and let the escalation
927                                          * process take care of it.
928                                          */
929                                         printk(KERN_WARNING
930                                                "scsi(%li:%i:%i:%i): Unable"
931                                                " to abort command!\n",
932                                                ha->host_no, bus, target, lun);
933                                 }
934                         }
935                 }
936                 break;
937
938         case ABORT_DEVICE:
939                 if (qla1280_verbose)
940                         printk(KERN_INFO
941                                "scsi(%ld:%d:%d:%d): Queueing abort device "
942                                "command.\n", ha->host_no, bus, target, lun);
943                 if (qla1280_abort_device(ha, bus, target, lun) == 0)
944                         result = SUCCESS;
945                 break;
946
947         case DEVICE_RESET:
948                 if (qla1280_verbose)
949                         printk(KERN_INFO
950                                "scsi(%ld:%d:%d:%d): Queueing device reset "
951                                "command.\n", ha->host_no, bus, target, lun);
952                 if (qla1280_device_reset(ha, bus, target) == 0)
953                         result = SUCCESS;
954                 break;
955
956         case BUS_RESET:
957                 if (qla1280_verbose)
958                         printk(KERN_INFO "qla1280(%ld:%d): Issuing BUS "
959                                "DEVICE RESET\n", ha->host_no, bus);
960                 if (qla1280_bus_reset(ha, bus == 0))
961                         result = SUCCESS;
962
963                 break;
964
965         case ADAPTER_RESET:
966         default:
967                 if (qla1280_verbose) {
968                         printk(KERN_INFO
969                                "scsi(%ld): Issued ADAPTER RESET\n",
970                                ha->host_no);
971                         printk(KERN_INFO "scsi(%ld): I/O processing will "
972                                "continue automatically\n", ha->host_no);
973                 }
974                 ha->flags.reset_active = 1;
975                 /*
976                  * We restarted all of the commands automatically, so the
977                  * mid-level code can expect completions momentitarily.
978                  */
979                 if (qla1280_abort_isp(ha) == 0)
980                         result = SUCCESS;
981
982                 ha->flags.reset_active = 0;
983         }
984
985         if (!list_empty(&ha->done_q))
986                 qla1280_done(ha);
987
988         /* If we didn't manage to issue the action, or we have no
989          * command to wait for, exit here */
990         if (result == FAILED || handle == NULL ||
991             handle == (unsigned char *)INVALID_HANDLE) {
992                 /*
993                  * Clear completion queue to avoid qla1280_done() trying
994                  * to complete the command at a later stage after we
995                  * have exited the current context
996                  */
997                 sp->wait = NULL;
998                 goto leave;
999         }
1000
1001         /* set up a timer just in case we're really jammed */
1002         init_timer(&timer);
1003         timer.expires = jiffies + 4*HZ;
1004         timer.data = (unsigned long)cmd;
1005         timer.function = qla1280_error_wait_timeout;
1006         add_timer(&timer);
1007
1008         /* wait for the action to complete (or the timer to expire) */
1009         spin_unlock_irq(ha->host->host_lock);
1010         wait_for_completion(&wait);
1011         del_timer_sync(&timer);
1012         spin_lock_irq(ha->host->host_lock);
1013         sp->wait = NULL;
1014
1015         /* the only action we might get a fail for is abort */
1016         if (action == ABORT_COMMAND) {
1017                 if(sp->flags & SRB_ABORTED)
1018                         result = SUCCESS;
1019                 else
1020                         result = FAILED;
1021         }
1022
1023  leave:
1024         dprintk(1, "RESET returning %d\n", result);
1025
1026         LEAVE("qla1280_error_action");
1027         return result;
1028 }
1029
1030 /**************************************************************************
1031  *   qla1280_abort
1032  *     Abort the specified SCSI command(s).
1033  **************************************************************************/
1034 static int
1035 qla1280_eh_abort(struct scsi_cmnd * cmd)
1036 {
1037         int rc;
1038
1039         spin_lock_irq(cmd->device->host->host_lock);
1040         rc = qla1280_error_action(cmd, ABORT_COMMAND);
1041         spin_unlock_irq(cmd->device->host->host_lock);
1042
1043         return rc;
1044 }
1045
1046 /**************************************************************************
1047  *   qla1280_device_reset
1048  *     Reset the specified SCSI device
1049  **************************************************************************/
1050 static int
1051 qla1280_eh_device_reset(struct scsi_cmnd *cmd)
1052 {
1053         int rc;
1054
1055         spin_lock_irq(cmd->device->host->host_lock);
1056         rc = qla1280_error_action(cmd, DEVICE_RESET);
1057         spin_unlock_irq(cmd->device->host->host_lock);
1058
1059         return rc;
1060 }
1061
1062 /**************************************************************************
1063  *   qla1280_bus_reset
1064  *     Reset the specified bus.
1065  **************************************************************************/
1066 static int
1067 qla1280_eh_bus_reset(struct scsi_cmnd *cmd)
1068 {
1069         int rc;
1070
1071         spin_lock_irq(cmd->device->host->host_lock);
1072         rc = qla1280_error_action(cmd, BUS_RESET);
1073         spin_unlock_irq(cmd->device->host->host_lock);
1074
1075         return rc;
1076 }
1077
1078 /**************************************************************************
1079  *   qla1280_adapter_reset
1080  *     Reset the specified adapter (both channels)
1081  **************************************************************************/
1082 static int
1083 qla1280_eh_adapter_reset(struct scsi_cmnd *cmd)
1084 {
1085         int rc;
1086
1087         spin_lock_irq(cmd->device->host->host_lock);
1088         rc = qla1280_error_action(cmd, ADAPTER_RESET);
1089         spin_unlock_irq(cmd->device->host->host_lock);
1090
1091         return rc;
1092 }
1093
1094 static int
1095 qla1280_biosparam(struct scsi_device *sdev, struct block_device *bdev,
1096                   sector_t capacity, int geom[])
1097 {
1098         int heads, sectors, cylinders;
1099
1100         heads = 64;
1101         sectors = 32;
1102         cylinders = (unsigned long)capacity / (heads * sectors);
1103         if (cylinders > 1024) {
1104                 heads = 255;
1105                 sectors = 63;
1106                 cylinders = (unsigned long)capacity / (heads * sectors);
1107                 /* if (cylinders > 1023)
1108                    cylinders = 1023; */
1109         }
1110
1111         geom[0] = heads;
1112         geom[1] = sectors;
1113         geom[2] = cylinders;
1114
1115         return 0;
1116 }
1117
1118  
1119 /* disable risc and host interrupts */
1120 static inline void
1121 qla1280_disable_intrs(struct scsi_qla_host *ha)
1122 {
1123         WRT_REG_WORD(&ha->iobase->ictrl, 0);
1124         RD_REG_WORD(&ha->iobase->ictrl);        /* PCI Posted Write flush */
1125 }
1126
1127 /* enable risc and host interrupts */
1128 static inline void
1129 qla1280_enable_intrs(struct scsi_qla_host *ha)
1130 {
1131         WRT_REG_WORD(&ha->iobase->ictrl, (ISP_EN_INT | ISP_EN_RISC));
1132         RD_REG_WORD(&ha->iobase->ictrl);        /* PCI Posted Write flush */
1133 }
1134
1135 /**************************************************************************
1136  * qla1280_intr_handler
1137  *   Handles the H/W interrupt
1138  **************************************************************************/
1139 static irqreturn_t
1140 qla1280_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1141 {
1142         struct scsi_qla_host *ha;
1143         struct device_reg __iomem *reg;
1144         u16 data;
1145         int handled = 0;
1146
1147         ENTER_INTR ("qla1280_intr_handler");
1148         ha = (struct scsi_qla_host *)dev_id;
1149
1150         spin_lock(ha->host->host_lock);
1151
1152         ha->isr_count++;
1153         reg = ha->iobase;
1154
1155         qla1280_disable_intrs(ha);
1156
1157         data = qla1280_debounce_register(&reg->istatus);
1158         /* Check for pending interrupts. */
1159         if (data & RISC_INT) {  
1160                 qla1280_isr(ha, &ha->done_q);
1161                 handled = 1;
1162         }
1163         if (!list_empty(&ha->done_q))
1164                 qla1280_done(ha);
1165
1166         spin_unlock(ha->host->host_lock);
1167
1168         qla1280_enable_intrs(ha);
1169
1170         LEAVE_INTR("qla1280_intr_handler");
1171         return IRQ_RETVAL(handled);
1172 }
1173
1174
1175 static int
1176 qla1280_set_target_parameters(struct scsi_qla_host *ha, int bus, int target)
1177 {
1178         uint8_t mr;
1179         uint16_t mb[MAILBOX_REGISTER_COUNT];
1180         struct nvram *nv;
1181         int status, lun;
1182
1183         nv = &ha->nvram;
1184
1185         mr = BIT_3 | BIT_2 | BIT_1 | BIT_0;
1186
1187         /* Set Target Parameters. */
1188         mb[0] = MBC_SET_TARGET_PARAMETERS;
1189         mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1190         mb[2] = nv->bus[bus].target[target].parameter.renegotiate_on_error << 8;
1191         mb[2] |= nv->bus[bus].target[target].parameter.stop_queue_on_check << 9;
1192         mb[2] |= nv->bus[bus].target[target].parameter.auto_request_sense << 10;
1193         mb[2] |= nv->bus[bus].target[target].parameter.tag_queuing << 11;
1194         mb[2] |= nv->bus[bus].target[target].parameter.enable_sync << 12;
1195         mb[2] |= nv->bus[bus].target[target].parameter.enable_wide << 13;
1196         mb[2] |= nv->bus[bus].target[target].parameter.parity_checking << 14;
1197         mb[2] |= nv->bus[bus].target[target].parameter.disconnect_allowed << 15;
1198
1199         if (IS_ISP1x160(ha)) {
1200                 mb[2] |= nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr << 5;
1201                 mb[3] = (nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8);
1202                 mb[6] = (nv->bus[bus].target[target].ppr_1x160.flags.ppr_options << 8) |
1203                          nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width;
1204                 mr |= BIT_6;
1205         } else {
1206                 mb[3] = (nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8);
1207         }
1208         mb[3] |= nv->bus[bus].target[target].sync_period;
1209
1210         status = qla1280_mailbox_command(ha, mr, mb);
1211
1212         /* Set Device Queue Parameters. */
1213         for (lun = 0; lun < MAX_LUNS; lun++) {
1214                 mb[0] = MBC_SET_DEVICE_QUEUE;
1215                 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
1216                 mb[1] |= lun;
1217                 mb[2] = nv->bus[bus].max_queue_depth;
1218                 mb[3] = nv->bus[bus].target[target].execution_throttle;
1219                 status |= qla1280_mailbox_command(ha, 0x0f, mb);
1220         }
1221
1222         if (status)
1223                 printk(KERN_WARNING "scsi(%ld:%i:%i): "
1224                        "qla1280_set_target_parameters() failed\n",
1225                        ha->host_no, bus, target);
1226         return status;
1227 }
1228
1229
1230 /**************************************************************************
1231  *   qla1280_slave_configure
1232  *
1233  * Description:
1234  *   Determines the queue depth for a given device.  There are two ways
1235  *   a queue depth can be obtained for a tagged queueing device.  One
1236  *   way is the default queue depth which is determined by whether
1237  *   If it is defined, then it is used
1238  *   as the default queue depth.  Otherwise, we use either 4 or 8 as the
1239  *   default queue depth (dependent on the number of hardware SCBs).
1240  **************************************************************************/
1241 static int
1242 qla1280_slave_configure(struct scsi_device *device)
1243 {
1244         struct scsi_qla_host *ha;
1245         int default_depth = 3;
1246         int bus = device->channel;
1247         int target = device->id;
1248         int status = 0;
1249         struct nvram *nv;
1250         unsigned long flags;
1251
1252         ha = (struct scsi_qla_host *)device->host->hostdata;
1253         nv = &ha->nvram;
1254
1255         if (qla1280_check_for_dead_scsi_bus(ha, bus))
1256                 return 1;
1257
1258         if (device->tagged_supported &&
1259             (ha->bus_settings[bus].qtag_enables & (BIT_0 << target))) {
1260                 scsi_adjust_queue_depth(device, MSG_ORDERED_TAG,
1261                                         ha->bus_settings[bus].hiwat);
1262         } else {
1263                 scsi_adjust_queue_depth(device, 0, default_depth);
1264         }
1265
1266         nv->bus[bus].target[target].parameter.enable_sync = device->sdtr;
1267         nv->bus[bus].target[target].parameter.enable_wide = device->wdtr;
1268         nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = device->ppr;
1269
1270         if (driver_setup.no_sync ||
1271             (driver_setup.sync_mask &&
1272              (~driver_setup.sync_mask & (1 << target))))
1273                 nv->bus[bus].target[target].parameter.enable_sync = 0;
1274         if (driver_setup.no_wide ||
1275             (driver_setup.wide_mask &&
1276              (~driver_setup.wide_mask & (1 << target))))
1277                 nv->bus[bus].target[target].parameter.enable_wide = 0;
1278         if (IS_ISP1x160(ha)) {
1279                 if (driver_setup.no_ppr ||
1280                     (driver_setup.ppr_mask &&
1281                      (~driver_setup.ppr_mask & (1 << target))))
1282                         nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 0;
1283         }
1284
1285         spin_lock_irqsave(ha->host->host_lock, flags);
1286         if (nv->bus[bus].target[target].parameter.enable_sync)
1287                 status = qla1280_set_target_parameters(ha, bus, target);
1288         qla1280_get_target_parameters(ha, device);
1289         spin_unlock_irqrestore(ha->host->host_lock, flags);
1290         return status;
1291 }
1292
1293
1294 /*
1295  * qla1280_done
1296  *      Process completed commands.
1297  *
1298  * Input:
1299  *      ha           = adapter block pointer.
1300  */
1301 static void
1302 qla1280_done(struct scsi_qla_host *ha)
1303 {
1304         struct srb *sp;
1305         struct list_head *done_q;
1306         int bus, target, lun;
1307         struct scsi_cmnd *cmd;
1308
1309         ENTER("qla1280_done");
1310
1311         done_q = &ha->done_q;
1312
1313         while (!list_empty(done_q)) {
1314                 sp = list_entry(done_q->next, struct srb, list);
1315
1316                 list_del(&sp->list);
1317         
1318                 cmd = sp->cmd;
1319                 bus = SCSI_BUS_32(cmd);
1320                 target = SCSI_TCN_32(cmd);
1321                 lun = SCSI_LUN_32(cmd);
1322
1323                 switch ((CMD_RESULT(cmd) >> 16)) {
1324                 case DID_RESET:
1325                         /* Issue marker command. */
1326                         qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
1327                         break;
1328                 case DID_ABORT:
1329                         sp->flags &= ~SRB_ABORT_PENDING;
1330                         sp->flags |= SRB_ABORTED;
1331                         if (sp->flags & SRB_TIMEOUT)
1332                                 CMD_RESULT(sp->cmd) = DID_TIME_OUT << 16;
1333                         break;
1334                 default:
1335                         break;
1336                 }
1337
1338                 /* Release memory used for this I/O */
1339                 if (cmd->use_sg) {
1340                         pci_unmap_sg(ha->pdev, cmd->request_buffer,
1341                                         cmd->use_sg, cmd->sc_data_direction);
1342                 } else if (cmd->request_bufflen) {
1343                         pci_unmap_single(ha->pdev, sp->saved_dma_handle,
1344                                         cmd->request_bufflen,
1345                                         cmd->sc_data_direction);
1346                 }
1347
1348                 /* Call the mid-level driver interrupt handler */
1349                 CMD_HANDLE(sp->cmd) = (unsigned char *)INVALID_HANDLE;
1350                 ha->actthreads--;
1351
1352                 (*(cmd)->scsi_done)(cmd);
1353
1354                 if(sp->wait != NULL)
1355                         complete(sp->wait);
1356         }
1357         LEAVE("qla1280_done");
1358 }
1359
1360 /*
1361  * Translates a ISP error to a Linux SCSI error
1362  */
1363 static int
1364 qla1280_return_status(struct response * sts, struct scsi_cmnd *cp)
1365 {
1366         int host_status = DID_ERROR;
1367         uint16_t comp_status = le16_to_cpu(sts->comp_status);
1368         uint16_t state_flags = le16_to_cpu(sts->state_flags);
1369         uint16_t residual_length = le32_to_cpu(sts->residual_length);
1370         uint16_t scsi_status = le16_to_cpu(sts->scsi_status);
1371 #if DEBUG_QLA1280_INTR
1372         static char *reason[] = {
1373                 "DID_OK",
1374                 "DID_NO_CONNECT",
1375                 "DID_BUS_BUSY",
1376                 "DID_TIME_OUT",
1377                 "DID_BAD_TARGET",
1378                 "DID_ABORT",
1379                 "DID_PARITY",
1380                 "DID_ERROR",
1381                 "DID_RESET",
1382                 "DID_BAD_INTR"
1383         };
1384 #endif                          /* DEBUG_QLA1280_INTR */
1385
1386         ENTER("qla1280_return_status");
1387
1388 #if DEBUG_QLA1280_INTR
1389         /*
1390           dprintk(1, "qla1280_return_status: compl status = 0x%04x\n",
1391           comp_status);
1392         */
1393 #endif
1394
1395         switch (comp_status) {
1396         case CS_COMPLETE:
1397                 host_status = DID_OK;
1398                 break;
1399
1400         case CS_INCOMPLETE:
1401                 if (!(state_flags & SF_GOT_BUS))
1402                         host_status = DID_NO_CONNECT;
1403                 else if (!(state_flags & SF_GOT_TARGET))
1404                         host_status = DID_BAD_TARGET;
1405                 else if (!(state_flags & SF_SENT_CDB))
1406                         host_status = DID_ERROR;
1407                 else if (!(state_flags & SF_TRANSFERRED_DATA))
1408                         host_status = DID_ERROR;
1409                 else if (!(state_flags & SF_GOT_STATUS))
1410                         host_status = DID_ERROR;
1411                 else if (!(state_flags & SF_GOT_SENSE))
1412                         host_status = DID_ERROR;
1413                 break;
1414
1415         case CS_RESET:
1416                 host_status = DID_RESET;
1417                 break;
1418
1419         case CS_ABORTED:
1420                 host_status = DID_ABORT;
1421                 break;
1422
1423         case CS_TIMEOUT:
1424                 host_status = DID_TIME_OUT;
1425                 break;
1426
1427         case CS_DATA_OVERRUN:
1428                 dprintk(2, "Data overrun 0x%x\n", residual_length);
1429                 dprintk(2, "qla1280_return_status: response packet data\n");
1430                 qla1280_dump_buffer(2, (char *)sts, RESPONSE_ENTRY_SIZE);
1431                 host_status = DID_ERROR;
1432                 break;
1433
1434         case CS_DATA_UNDERRUN:
1435                 if ((cp->request_bufflen - residual_length) <
1436                     cp->underflow) {
1437                         printk(KERN_WARNING
1438                                "scsi: Underflow detected - retrying "
1439                                "command.\n");
1440                         host_status = DID_ERROR;
1441                 } else
1442                         host_status = DID_OK;
1443                 break;
1444
1445         default:
1446                 host_status = DID_ERROR;
1447                 break;
1448         }
1449
1450 #if DEBUG_QLA1280_INTR
1451         dprintk(1, "qla1280 ISP status: host status (%s) scsi status %x\n",
1452                 reason[host_status], scsi_status);
1453 #endif
1454
1455         LEAVE("qla1280_return_status");
1456
1457         return (scsi_status & 0xff) | (host_status << 16);
1458 }
1459
1460 /****************************************************************************/
1461 /*                QLogic ISP1280 Hardware Support Functions.                */
1462 /****************************************************************************/
1463
1464 /*
1465  * qla1280_initialize_adapter
1466  *      Initialize board.
1467  *
1468  * Input:
1469  *      ha = adapter block pointer.
1470  *
1471  * Returns:
1472  *      0 = success
1473  */
1474 static int __devinit
1475 qla1280_initialize_adapter(struct scsi_qla_host *ha)
1476 {
1477         struct device_reg __iomem *reg;
1478         int status;
1479         int bus;
1480         unsigned long flags;
1481
1482         ENTER("qla1280_initialize_adapter");
1483
1484         /* Clear adapter flags. */
1485         ha->flags.online = 0;
1486         ha->flags.disable_host_adapter = 0;
1487         ha->flags.reset_active = 0;
1488         ha->flags.abort_isp_active = 0;
1489
1490 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
1491         if (ia64_platform_is("sn2")) {
1492                 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
1493                        "dual channel lockup workaround\n", ha->host_no);
1494                 ha->flags.use_pci_vchannel = 1;
1495                 driver_setup.no_nvram = 1;
1496         }
1497 #endif
1498
1499         /* TODO: implement support for the 1040 nvram format */
1500         if (IS_ISP1040(ha))
1501                 driver_setup.no_nvram = 1;
1502
1503         dprintk(1, "Configure PCI space for adapter...\n");
1504
1505         reg = ha->iobase;
1506
1507         /* Insure mailbox registers are free. */
1508         WRT_REG_WORD(&reg->semaphore, 0);
1509         WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
1510         WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
1511         RD_REG_WORD(&reg->host_cmd);
1512
1513         if (qla1280_read_nvram(ha)) {
1514                 dprintk(2, "qla1280_initialize_adapter: failed to read "
1515                         "NVRAM\n");
1516         }
1517
1518         /*
1519          * It's necessary to grab the spin here as qla1280_mailbox_command
1520          * needs to be able to drop the lock unconditionally to wait
1521          * for completion.
1522          */
1523         spin_lock_irqsave(ha->host->host_lock, flags);
1524
1525         status = qla1280_load_firmware(ha);
1526         if (status) {
1527                 printk(KERN_ERR "scsi(%li): initialize: pci probe failed!\n",
1528                        ha->host_no);
1529                 goto out;
1530         }
1531
1532         /* Setup adapter based on NVRAM parameters. */
1533         dprintk(1, "scsi(%ld): Configure NVRAM parameters\n", ha->host_no);
1534         qla1280_nvram_config(ha);
1535
1536         if (ha->flags.disable_host_adapter) {
1537                 status = 1;
1538                 goto out;
1539         }
1540
1541         status = qla1280_init_rings(ha);
1542         if (status)
1543                 goto out;
1544
1545         /* Issue SCSI reset, if we can't reset twice then bus is dead */
1546         for (bus = 0; bus < ha->ports; bus++) {
1547                 if (!ha->bus_settings[bus].disable_scsi_reset &&
1548                     qla1280_bus_reset(ha, bus) &&
1549                     qla1280_bus_reset(ha, bus))
1550                         ha->bus_settings[bus].scsi_bus_dead = 1;
1551         }
1552
1553         ha->flags.online = 1;
1554  out:
1555         spin_unlock_irqrestore(ha->host->host_lock, flags);
1556
1557         if (status)
1558                 dprintk(2, "qla1280_initialize_adapter: **** FAILED ****\n");
1559
1560         LEAVE("qla1280_initialize_adapter");
1561         return status;
1562 }
1563
1564 /*
1565  * Chip diagnostics
1566  *      Test chip for proper operation.
1567  *
1568  * Input:
1569  *      ha = adapter block pointer.
1570  *
1571  * Returns:
1572  *      0 = success.
1573  */
1574 static int
1575 qla1280_chip_diag(struct scsi_qla_host *ha)
1576 {
1577         uint16_t mb[MAILBOX_REGISTER_COUNT];
1578         struct device_reg __iomem *reg = ha->iobase;
1579         int status = 0;
1580         int cnt;
1581         uint16_t data;
1582         dprintk(3, "qla1280_chip_diag: testing device at 0x%p \n", &reg->id_l);
1583
1584         dprintk(1, "scsi(%ld): Verifying chip\n", ha->host_no);
1585
1586         /* Soft reset chip and wait for it to finish. */
1587         WRT_REG_WORD(&reg->ictrl, ISP_RESET);
1588
1589         /*
1590          * We can't do a traditional PCI write flush here by reading
1591          * back the register. The card will not respond once the reset
1592          * is in action and we end up with a machine check exception
1593          * instead. Nothing to do but wait and hope for the best.
1594          * A portable pci_write_flush(pdev) call would be very useful here.
1595          */
1596         udelay(20);
1597         data = qla1280_debounce_register(&reg->ictrl);
1598         /*
1599          * Yet another QLogic gem ;-(
1600          */
1601         for (cnt = 1000000; cnt && data & ISP_RESET; cnt--) {
1602                 udelay(5);
1603                 data = RD_REG_WORD(&reg->ictrl);
1604         }
1605
1606         if (!cnt)
1607                 goto fail;
1608
1609         /* Reset register cleared by chip reset. */
1610         dprintk(3, "qla1280_chip_diag: reset register cleared by chip reset\n");
1611
1612         WRT_REG_WORD(&reg->cfg_1, 0);
1613
1614         /* Reset RISC and disable BIOS which
1615            allows RISC to execute out of RAM. */
1616         WRT_REG_WORD(&reg->host_cmd, HC_RESET_RISC |
1617                      HC_RELEASE_RISC | HC_DISABLE_BIOS);
1618
1619         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
1620         data = qla1280_debounce_register(&reg->mailbox0);
1621
1622         /*
1623          * I *LOVE* this code!
1624          */
1625         for (cnt = 1000000; cnt && data == MBS_BUSY; cnt--) {
1626                 udelay(5);
1627                 data = RD_REG_WORD(&reg->mailbox0);
1628         }
1629
1630         if (!cnt)
1631                 goto fail;
1632
1633         /* Check product ID of chip */
1634         dprintk(3, "qla1280_chip_diag: Checking product ID of chip\n");
1635
1636         if (RD_REG_WORD(&reg->mailbox1) != PROD_ID_1 ||
1637             (RD_REG_WORD(&reg->mailbox2) != PROD_ID_2 &&
1638              RD_REG_WORD(&reg->mailbox2) != PROD_ID_2a) ||
1639             RD_REG_WORD(&reg->mailbox3) != PROD_ID_3 ||
1640             RD_REG_WORD(&reg->mailbox4) != PROD_ID_4) {
1641                 printk(KERN_INFO "qla1280: Wrong product ID = "
1642                        "0x%x,0x%x,0x%x,0x%x\n",
1643                        RD_REG_WORD(&reg->mailbox1),
1644                        RD_REG_WORD(&reg->mailbox2),
1645                        RD_REG_WORD(&reg->mailbox3),
1646                        RD_REG_WORD(&reg->mailbox4));
1647                 goto fail;
1648         }
1649
1650         /*
1651          * Enable ints early!!!
1652          */
1653         qla1280_enable_intrs(ha);
1654
1655         dprintk(1, "qla1280_chip_diag: Checking mailboxes of chip\n");
1656         /* Wrap Incoming Mailboxes Test. */
1657         mb[0] = MBC_MAILBOX_REGISTER_TEST;
1658         mb[1] = 0xAAAA;
1659         mb[2] = 0x5555;
1660         mb[3] = 0xAA55;
1661         mb[4] = 0x55AA;
1662         mb[5] = 0xA5A5;
1663         mb[6] = 0x5A5A;
1664         mb[7] = 0x2525;
1665
1666         status = qla1280_mailbox_command(ha, 0xff, mb);
1667         if (status)
1668                 goto fail;
1669
1670         if (mb[1] != 0xAAAA || mb[2] != 0x5555 || mb[3] != 0xAA55 ||
1671             mb[4] != 0x55AA || mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
1672             mb[7] != 0x2525) {
1673                 printk(KERN_INFO "qla1280: Failed mbox check\n");
1674                 goto fail;
1675         }
1676
1677         dprintk(3, "qla1280_chip_diag: exiting normally\n");
1678         return 0;
1679  fail:
1680         dprintk(2, "qla1280_chip_diag: **** FAILED ****\n");
1681         return status;
1682 }
1683
1684 static int
1685 qla1280_load_firmware_pio(struct scsi_qla_host *ha)
1686 {
1687         uint16_t risc_address, *risc_code_address, risc_code_size;
1688         uint16_t mb[MAILBOX_REGISTER_COUNT], i;
1689         int err;
1690
1691         /* Load RISC code. */
1692         risc_address = *ql1280_board_tbl[ha->devnum].fwstart;
1693         risc_code_address = ql1280_board_tbl[ha->devnum].fwcode;
1694         risc_code_size = *ql1280_board_tbl[ha->devnum].fwlen;
1695
1696         for (i = 0; i < risc_code_size; i++) {
1697                 mb[0] = MBC_WRITE_RAM_WORD;
1698                 mb[1] = risc_address + i;
1699                 mb[2] = risc_code_address[i];
1700
1701                 err = qla1280_mailbox_command(ha, BIT_0 | BIT_1 | BIT_2, mb);
1702                 if (err) {
1703                         printk(KERN_ERR "scsi(%li): Failed to load firmware\n",
1704                                         ha->host_no);
1705                         return err;
1706                 }
1707         }
1708
1709         return 0;
1710 }
1711
1712 #define DUMP_IT_BACK 0          /* for debug of RISC loading */
1713 static int
1714 qla1280_load_firmware_dma(struct scsi_qla_host *ha)
1715 {
1716         uint16_t risc_address, *risc_code_address, risc_code_size;
1717         uint16_t mb[MAILBOX_REGISTER_COUNT], cnt;
1718         int err = 0, num, i;
1719 #if DUMP_IT_BACK
1720         uint8_t *sp, *tbuf;
1721         dma_addr_t p_tbuf;
1722
1723         tbuf = pci_alloc_consistent(ha->pdev, 8000, &p_tbuf);
1724         if (!tbuf)
1725                 return -ENOMEM;
1726 #endif
1727
1728         /* Load RISC code. */
1729         risc_address = *ql1280_board_tbl[ha->devnum].fwstart;
1730         risc_code_address = ql1280_board_tbl[ha->devnum].fwcode;
1731         risc_code_size = *ql1280_board_tbl[ha->devnum].fwlen;
1732
1733         dprintk(1, "%s: DMA RISC code (%i) words\n",
1734                         __FUNCTION__, risc_code_size);
1735
1736         num = 0;
1737         while (risc_code_size > 0) {
1738                 int warn __attribute__((unused)) = 0;
1739
1740                 cnt = 2000 >> 1;
1741
1742                 if (cnt > risc_code_size)
1743                         cnt = risc_code_size;
1744
1745                 dprintk(2, "qla1280_setup_chip:  loading risc @ =(0x%p),"
1746                         "%d,%d(0x%x)\n",
1747                         risc_code_address, cnt, num, risc_address);
1748                 for(i = 0; i < cnt; i++)
1749                         ((__le16 *)ha->request_ring)[i] =
1750                                 cpu_to_le16(risc_code_address[i]);
1751
1752                 mb[0] = MBC_LOAD_RAM;
1753                 mb[1] = risc_address;
1754                 mb[4] = cnt;
1755                 mb[3] = ha->request_dma & 0xffff;
1756                 mb[2] = (ha->request_dma >> 16) & 0xffff;
1757                 mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
1758                 mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
1759                 dprintk(2, "%s: op=%d  0x%p = 0x%4x,0x%4x,0x%4x,0x%4x\n",
1760                                 __FUNCTION__, mb[0],
1761                                 (void *)(long)ha->request_dma,
1762                                 mb[6], mb[7], mb[2], mb[3]);
1763                 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1764                                 BIT_1 | BIT_0, mb);
1765                 if (err) {
1766                         printk(KERN_ERR "scsi(%li): Failed to load partial "
1767                                "segment of f\n", ha->host_no);
1768                         goto out;
1769                 }
1770
1771 #if DUMP_IT_BACK
1772                 mb[0] = MBC_DUMP_RAM;
1773                 mb[1] = risc_address;
1774                 mb[4] = cnt;
1775                 mb[3] = p_tbuf & 0xffff;
1776                 mb[2] = (p_tbuf >> 16) & 0xffff;
1777                 mb[7] = pci_dma_hi32(p_tbuf) & 0xffff;
1778                 mb[6] = pci_dma_hi32(p_tbuf) >> 16;
1779
1780                 err = qla1280_mailbox_command(ha, BIT_4 | BIT_3 | BIT_2 |
1781                                 BIT_1 | BIT_0, mb);
1782                 if (err) {
1783                         printk(KERN_ERR
1784                                "Failed to dump partial segment of f/w\n");
1785                         goto out;
1786                 }
1787                 sp = (uint8_t *)ha->request_ring;
1788                 for (i = 0; i < (cnt << 1); i++) {
1789                         if (tbuf[i] != sp[i] && warn++ < 10) {
1790                                 printk(KERN_ERR "%s: FW compare error @ "
1791                                                 "byte(0x%x) loop#=%x\n",
1792                                                 __FUNCTION__, i, num);
1793                                 printk(KERN_ERR "%s: FWbyte=%x  "
1794                                                 "FWfromChip=%x\n",
1795                                                 __FUNCTION__, sp[i], tbuf[i]);
1796                                 /*break; */
1797                         }
1798                 }
1799 #endif
1800                 risc_address += cnt;
1801                 risc_code_size = risc_code_size - cnt;
1802                 risc_code_address = risc_code_address + cnt;
1803                 num++;
1804         }
1805
1806  out:
1807 #if DUMP_IT_BACK
1808         pci_free_consistent(ha->pdev, 8000, tbuf, p_tbuf);
1809 #endif
1810         return err;
1811 }
1812
1813 static int
1814 qla1280_start_firmware(struct scsi_qla_host *ha)
1815 {
1816         uint16_t mb[MAILBOX_REGISTER_COUNT];
1817         int err;
1818
1819         dprintk(1, "%s: Verifying checksum of loaded RISC code.\n",
1820                         __FUNCTION__);
1821
1822         /* Verify checksum of loaded RISC code. */
1823         mb[0] = MBC_VERIFY_CHECKSUM;
1824         /* mb[1] = ql12_risc_code_addr01; */
1825         mb[1] = *ql1280_board_tbl[ha->devnum].fwstart;
1826         err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
1827         if (err) {
1828                 printk(KERN_ERR "scsi(%li): RISC checksum failed.\n", ha->host_no);
1829                 return err;
1830         }
1831
1832         /* Start firmware execution. */
1833         dprintk(1, "%s: start firmware running.\n", __FUNCTION__);
1834         mb[0] = MBC_EXECUTE_FIRMWARE;
1835         mb[1] = *ql1280_board_tbl[ha->devnum].fwstart;
1836         err = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
1837         if (err) {
1838                 printk(KERN_ERR "scsi(%li): Failed to start firmware\n",
1839                                 ha->host_no);
1840         }
1841
1842         return err;
1843 }
1844
1845 static int
1846 qla1280_load_firmware(struct scsi_qla_host *ha)
1847 {
1848         int err;
1849
1850         err = qla1280_chip_diag(ha);
1851         if (err)
1852                 goto out;
1853         if (IS_ISP1040(ha))
1854                 err = qla1280_load_firmware_pio(ha);
1855         else
1856                 err = qla1280_load_firmware_dma(ha);
1857         if (err)
1858                 goto out;
1859         err = qla1280_start_firmware(ha);
1860  out:
1861         return err;
1862 }
1863
1864 /*
1865  * Initialize rings
1866  *
1867  * Input:
1868  *      ha                = adapter block pointer.
1869  *      ha->request_ring  = request ring virtual address
1870  *      ha->response_ring = response ring virtual address
1871  *      ha->request_dma   = request ring physical address
1872  *      ha->response_dma  = response ring physical address
1873  *
1874  * Returns:
1875  *      0 = success.
1876  */
1877 static int
1878 qla1280_init_rings(struct scsi_qla_host *ha)
1879 {
1880         uint16_t mb[MAILBOX_REGISTER_COUNT];
1881         int status = 0;
1882
1883         ENTER("qla1280_init_rings");
1884
1885         /* Clear outstanding commands array. */
1886         memset(ha->outstanding_cmds, 0,
1887                sizeof(struct srb *) * MAX_OUTSTANDING_COMMANDS);
1888
1889         /* Initialize request queue. */
1890         ha->request_ring_ptr = ha->request_ring;
1891         ha->req_ring_index = 0;
1892         ha->req_q_cnt = REQUEST_ENTRY_CNT;
1893         /* mb[0] = MBC_INIT_REQUEST_QUEUE; */
1894         mb[0] = MBC_INIT_REQUEST_QUEUE_A64;
1895         mb[1] = REQUEST_ENTRY_CNT;
1896         mb[3] = ha->request_dma & 0xffff;
1897         mb[2] = (ha->request_dma >> 16) & 0xffff;
1898         mb[4] = 0;
1899         mb[7] = pci_dma_hi32(ha->request_dma) & 0xffff;
1900         mb[6] = pci_dma_hi32(ha->request_dma) >> 16;
1901         if (!(status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_4 |
1902                                                BIT_3 | BIT_2 | BIT_1 | BIT_0,
1903                                                &mb[0]))) {
1904                 /* Initialize response queue. */
1905                 ha->response_ring_ptr = ha->response_ring;
1906                 ha->rsp_ring_index = 0;
1907                 /* mb[0] = MBC_INIT_RESPONSE_QUEUE; */
1908                 mb[0] = MBC_INIT_RESPONSE_QUEUE_A64;
1909                 mb[1] = RESPONSE_ENTRY_CNT;
1910                 mb[3] = ha->response_dma & 0xffff;
1911                 mb[2] = (ha->response_dma >> 16) & 0xffff;
1912                 mb[5] = 0;
1913                 mb[7] = pci_dma_hi32(ha->response_dma) & 0xffff;
1914                 mb[6] = pci_dma_hi32(ha->response_dma) >> 16;
1915                 status = qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_5 |
1916                                                  BIT_3 | BIT_2 | BIT_1 | BIT_0,
1917                                                  &mb[0]);
1918         }
1919
1920         if (status)
1921                 dprintk(2, "qla1280_init_rings: **** FAILED ****\n");
1922
1923         LEAVE("qla1280_init_rings");
1924         return status;
1925 }
1926
1927 static void
1928 qla1280_print_settings(struct nvram *nv)
1929 {
1930         dprintk(1, "qla1280 : initiator scsi id bus[0]=%d\n",
1931                 nv->bus[0].config_1.initiator_id);
1932         dprintk(1, "qla1280 : initiator scsi id bus[1]=%d\n",
1933                 nv->bus[1].config_1.initiator_id);
1934
1935         dprintk(1, "qla1280 : bus reset delay[0]=%d\n",
1936                 nv->bus[0].bus_reset_delay);
1937         dprintk(1, "qla1280 : bus reset delay[1]=%d\n",
1938                 nv->bus[1].bus_reset_delay);
1939
1940         dprintk(1, "qla1280 : retry count[0]=%d\n", nv->bus[0].retry_count);
1941         dprintk(1, "qla1280 : retry delay[0]=%d\n", nv->bus[0].retry_delay);
1942         dprintk(1, "qla1280 : retry count[1]=%d\n", nv->bus[1].retry_count);
1943         dprintk(1, "qla1280 : retry delay[1]=%d\n", nv->bus[1].retry_delay);
1944
1945         dprintk(1, "qla1280 : async data setup time[0]=%d\n",
1946                 nv->bus[0].config_2.async_data_setup_time);
1947         dprintk(1, "qla1280 : async data setup time[1]=%d\n",
1948                 nv->bus[1].config_2.async_data_setup_time);
1949
1950         dprintk(1, "qla1280 : req/ack active negation[0]=%d\n",
1951                 nv->bus[0].config_2.req_ack_active_negation);
1952         dprintk(1, "qla1280 : req/ack active negation[1]=%d\n",
1953                 nv->bus[1].config_2.req_ack_active_negation);
1954
1955         dprintk(1, "qla1280 : data line active negation[0]=%d\n",
1956                 nv->bus[0].config_2.data_line_active_negation);
1957         dprintk(1, "qla1280 : data line active negation[1]=%d\n",
1958                 nv->bus[1].config_2.data_line_active_negation);
1959
1960         dprintk(1, "qla1280 : disable loading risc code=%d\n",
1961                 nv->cntr_flags_1.disable_loading_risc_code);
1962
1963         dprintk(1, "qla1280 : enable 64bit addressing=%d\n",
1964                 nv->cntr_flags_1.enable_64bit_addressing);
1965
1966         dprintk(1, "qla1280 : selection timeout limit[0]=%d\n",
1967                 nv->bus[0].selection_timeout);
1968         dprintk(1, "qla1280 : selection timeout limit[1]=%d\n",
1969                 nv->bus[1].selection_timeout);
1970
1971         dprintk(1, "qla1280 : max queue depth[0]=%d\n",
1972                 nv->bus[0].max_queue_depth);
1973         dprintk(1, "qla1280 : max queue depth[1]=%d\n",
1974                 nv->bus[1].max_queue_depth);
1975 }
1976
1977 static void
1978 qla1280_set_target_defaults(struct scsi_qla_host *ha, int bus, int target)
1979 {
1980         struct nvram *nv = &ha->nvram;
1981
1982         nv->bus[bus].target[target].parameter.renegotiate_on_error = 1;
1983         nv->bus[bus].target[target].parameter.auto_request_sense = 1;
1984         nv->bus[bus].target[target].parameter.tag_queuing = 1;
1985         nv->bus[bus].target[target].parameter.enable_sync = 1;
1986 #if 1   /* Some SCSI Processors do not seem to like this */
1987         nv->bus[bus].target[target].parameter.enable_wide = 1;
1988 #endif
1989         nv->bus[bus].target[target].execution_throttle =
1990                 nv->bus[bus].max_queue_depth - 1;
1991         nv->bus[bus].target[target].parameter.parity_checking = 1;
1992         nv->bus[bus].target[target].parameter.disconnect_allowed = 1;
1993
1994         if (IS_ISP1x160(ha)) {
1995                 nv->bus[bus].target[target].flags.flags1x160.device_enable = 1;
1996                 nv->bus[bus].target[target].flags.flags1x160.sync_offset = 0x0e;
1997                 nv->bus[bus].target[target].sync_period = 9;
1998                 nv->bus[bus].target[target].ppr_1x160.flags.enable_ppr = 1;
1999                 nv->bus[bus].target[target].ppr_1x160.flags.ppr_options = 2;
2000                 nv->bus[bus].target[target].ppr_1x160.flags.ppr_bus_width = 1;
2001         } else {
2002                 nv->bus[bus].target[target].flags.flags1x80.device_enable = 1;
2003                 nv->bus[bus].target[target].flags.flags1x80.sync_offset = 12;
2004                 nv->bus[bus].target[target].sync_period = 10;
2005         }
2006 }
2007
2008 static void
2009 qla1280_set_defaults(struct scsi_qla_host *ha)
2010 {
2011         struct nvram *nv = &ha->nvram;
2012         int bus, target;
2013
2014         dprintk(1, "Using defaults for NVRAM: \n");
2015         memset(nv, 0, sizeof(struct nvram));
2016
2017         /* nv->cntr_flags_1.disable_loading_risc_code = 1; */
2018         nv->firmware_feature.f.enable_fast_posting = 1;
2019         nv->firmware_feature.f.disable_synchronous_backoff = 1;
2020         nv->termination.scsi_bus_0_control = 3;
2021         nv->termination.scsi_bus_1_control = 3;
2022         nv->termination.auto_term_support = 1;
2023
2024         /*
2025          * Set default FIFO magic - What appropriate values would be here
2026          * is unknown. This is what I have found testing with 12160s.
2027          *
2028          * Now, I would love the magic decoder ring for this one, the
2029          * header file provided by QLogic seems to be bogus or incomplete
2030          * at best.
2031          */
2032         nv->isp_config.burst_enable = 1;
2033         if (IS_ISP1040(ha))
2034                 nv->isp_config.fifo_threshold |= 3;
2035         else
2036                 nv->isp_config.fifo_threshold |= 4;
2037
2038         if (IS_ISP1x160(ha))
2039                 nv->isp_parameter = 0x01; /* fast memory enable */
2040
2041         for (bus = 0; bus < MAX_BUSES; bus++) {
2042                 nv->bus[bus].config_1.initiator_id = 7;
2043                 nv->bus[bus].config_2.req_ack_active_negation = 1;
2044                 nv->bus[bus].config_2.data_line_active_negation = 1;
2045                 nv->bus[bus].selection_timeout = 250;
2046                 nv->bus[bus].max_queue_depth = 256;
2047
2048                 if (IS_ISP1040(ha)) {
2049                         nv->bus[bus].bus_reset_delay = 3;
2050                         nv->bus[bus].config_2.async_data_setup_time = 6;
2051                         nv->bus[bus].retry_delay = 1;
2052                 } else {
2053                         nv->bus[bus].bus_reset_delay = 5;
2054                         nv->bus[bus].config_2.async_data_setup_time = 8;
2055                 }
2056
2057                 for (target = 0; target < MAX_TARGETS; target++)
2058                         qla1280_set_target_defaults(ha, bus, target);
2059         }
2060 }
2061
2062 static int
2063 qla1280_config_target(struct scsi_qla_host *ha, int bus, int target)
2064 {
2065         struct nvram *nv = &ha->nvram;
2066         uint16_t mb[MAILBOX_REGISTER_COUNT];
2067         int status, lun;
2068         uint16_t flag;
2069
2070         /* Set Target Parameters. */
2071         mb[0] = MBC_SET_TARGET_PARAMETERS;
2072         mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2073
2074         /*
2075          * Do not enable sync and ppr for the initial INQUIRY run. We
2076          * enable this later if we determine the target actually
2077          * supports it.
2078          */
2079         mb[2] = (TP_RENEGOTIATE | TP_AUTO_REQUEST_SENSE | TP_TAGGED_QUEUE
2080                  | TP_WIDE | TP_PARITY | TP_DISCONNECT);
2081
2082         if (IS_ISP1x160(ha))
2083                 mb[3] = nv->bus[bus].target[target].flags.flags1x160.sync_offset << 8;
2084         else
2085                 mb[3] = nv->bus[bus].target[target].flags.flags1x80.sync_offset << 8;
2086         mb[3] |= nv->bus[bus].target[target].sync_period;
2087         status = qla1280_mailbox_command(ha, 0x0f, mb);
2088
2089         /* Save Tag queuing enable flag. */
2090         flag = (BIT_0 << target) & mb[0];
2091         if (nv->bus[bus].target[target].parameter.tag_queuing)
2092                 ha->bus_settings[bus].qtag_enables |= flag;
2093
2094         /* Save Device enable flag. */
2095         if (IS_ISP1x160(ha)) {
2096                 if (nv->bus[bus].target[target].flags.flags1x160.device_enable)
2097                         ha->bus_settings[bus].device_enables |= flag;
2098                 ha->bus_settings[bus].lun_disables |= 0;
2099         } else {
2100                 if (nv->bus[bus].target[target].flags.flags1x80.device_enable)
2101                         ha->bus_settings[bus].device_enables |= flag;
2102                 /* Save LUN disable flag. */
2103                 if (nv->bus[bus].target[target].flags.flags1x80.lun_disable)
2104                         ha->bus_settings[bus].lun_disables |= flag;
2105         }
2106
2107         /* Set Device Queue Parameters. */
2108         for (lun = 0; lun < MAX_LUNS; lun++) {
2109                 mb[0] = MBC_SET_DEVICE_QUEUE;
2110                 mb[1] = (uint16_t)((bus ? target | BIT_7 : target) << 8);
2111                 mb[1] |= lun;
2112                 mb[2] = nv->bus[bus].max_queue_depth;
2113                 mb[3] = nv->bus[bus].target[target].execution_throttle;
2114                 status |= qla1280_mailbox_command(ha, 0x0f, mb);
2115         }
2116
2117         return status;
2118 }
2119
2120 static int
2121 qla1280_config_bus(struct scsi_qla_host *ha, int bus)
2122 {
2123         struct nvram *nv = &ha->nvram;
2124         uint16_t mb[MAILBOX_REGISTER_COUNT];
2125         int target, status;
2126
2127         /* SCSI Reset Disable. */
2128         ha->bus_settings[bus].disable_scsi_reset =
2129                 nv->bus[bus].config_1.scsi_reset_disable;
2130
2131         /* Initiator ID. */
2132         ha->bus_settings[bus].id = nv->bus[bus].config_1.initiator_id;
2133         mb[0] = MBC_SET_INITIATOR_ID;
2134         mb[1] = bus ? ha->bus_settings[bus].id | BIT_7 :
2135                 ha->bus_settings[bus].id;
2136         status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2137
2138         /* Reset Delay. */
2139         ha->bus_settings[bus].bus_reset_delay =
2140                 nv->bus[bus].bus_reset_delay;
2141
2142         /* Command queue depth per device. */
2143         ha->bus_settings[bus].hiwat = nv->bus[bus].max_queue_depth - 1;
2144
2145         /* Set target parameters. */
2146         for (target = 0; target < MAX_TARGETS; target++)
2147                 status |= qla1280_config_target(ha, bus, target);
2148
2149         return status;
2150 }
2151
2152 static int
2153 qla1280_nvram_config(struct scsi_qla_host *ha)
2154 {
2155         struct device_reg __iomem *reg = ha->iobase;
2156         struct nvram *nv = &ha->nvram;
2157         int bus, target, status = 0;
2158         uint16_t mb[MAILBOX_REGISTER_COUNT];
2159
2160         ENTER("qla1280_nvram_config");
2161
2162         if (ha->nvram_valid) {
2163                 /* Always force AUTO sense for LINUX SCSI */
2164                 for (bus = 0; bus < MAX_BUSES; bus++)
2165                         for (target = 0; target < MAX_TARGETS; target++) {
2166                                 nv->bus[bus].target[target].parameter.
2167                                         auto_request_sense = 1;
2168                         }
2169         } else {
2170                 qla1280_set_defaults(ha);
2171         }
2172
2173         qla1280_print_settings(nv);
2174
2175         /* Disable RISC load of firmware. */
2176         ha->flags.disable_risc_code_load =
2177                 nv->cntr_flags_1.disable_loading_risc_code;
2178
2179         if (IS_ISP1040(ha)) {
2180                 uint16_t hwrev, cfg1, cdma_conf, ddma_conf;
2181
2182                 hwrev = RD_REG_WORD(&reg->cfg_0) & ISP_CFG0_HWMSK;
2183
2184                 cfg1 = RD_REG_WORD(&reg->cfg_1) & ~(BIT_4 | BIT_5 | BIT_6);
2185                 cdma_conf = RD_REG_WORD(&reg->cdma_cfg);
2186                 ddma_conf = RD_REG_WORD(&reg->ddma_cfg);
2187
2188                 /* Busted fifo, says mjacob. */
2189                 if (hwrev != ISP_CFG0_1040A)
2190                         cfg1 |= nv->isp_config.fifo_threshold << 4;
2191
2192                 cfg1 |= nv->isp_config.burst_enable << 2;
2193                 WRT_REG_WORD(&reg->cfg_1, cfg1);
2194
2195                 WRT_REG_WORD(&reg->cdma_cfg, cdma_conf | CDMA_CONF_BENAB);
2196                 WRT_REG_WORD(&reg->ddma_cfg, cdma_conf | DDMA_CONF_BENAB);
2197         } else {
2198                 uint16_t cfg1, term;
2199
2200                 /* Set ISP hardware DMA burst */
2201                 cfg1 = nv->isp_config.fifo_threshold << 4;
2202                 cfg1 |= nv->isp_config.burst_enable << 2;
2203                 /* Enable DMA arbitration on dual channel controllers */
2204                 if (ha->ports > 1)
2205                         cfg1 |= BIT_13;
2206                 WRT_REG_WORD(&reg->cfg_1, cfg1);
2207
2208                 /* Set SCSI termination. */
2209                 WRT_REG_WORD(&reg->gpio_enable,
2210                              BIT_7 | BIT_3 | BIT_2 | BIT_1 | BIT_0);
2211                 term = nv->termination.scsi_bus_1_control;
2212                 term |= nv->termination.scsi_bus_0_control << 2;
2213                 term |= nv->termination.auto_term_support << 7;
2214                 RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2215                 WRT_REG_WORD(&reg->gpio_data, term);
2216         }
2217         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2218
2219         /* ISP parameter word. */
2220         mb[0] = MBC_SET_SYSTEM_PARAMETER;
2221         mb[1] = nv->isp_parameter;
2222         status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2223
2224         if (IS_ISP1x40(ha)) {
2225                 /* clock rate - for qla1240 and older, only */
2226                 mb[0] = MBC_SET_CLOCK_RATE;
2227                 mb[1] = 40;
2228                 status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2229         }
2230
2231         /* Firmware feature word. */
2232         mb[0] = MBC_SET_FIRMWARE_FEATURES;
2233         mb[1] = nv->firmware_feature.f.enable_fast_posting;
2234         mb[1] |= nv->firmware_feature.f.report_lvd_bus_transition << 1;
2235         mb[1] |= nv->firmware_feature.f.disable_synchronous_backoff << 5;
2236 #if defined(CONFIG_IA64_GENERIC) || defined (CONFIG_IA64_SGI_SN2)
2237         if (ia64_platform_is("sn2")) {
2238                 printk(KERN_INFO "scsi(%li): Enabling SN2 PCI DMA "
2239                        "workaround\n", ha->host_no);
2240                 mb[1] |= nv->firmware_feature.f.unused_9 << 9; /* XXX */
2241         }
2242 #endif
2243         status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2244
2245         /* Retry count and delay. */
2246         mb[0] = MBC_SET_RETRY_COUNT;
2247         mb[1] = nv->bus[0].retry_count;
2248         mb[2] = nv->bus[0].retry_delay;
2249         mb[6] = nv->bus[1].retry_count;
2250         mb[7] = nv->bus[1].retry_delay;
2251         status |= qla1280_mailbox_command(ha, BIT_7 | BIT_6 | BIT_2 |
2252                                           BIT_1 | BIT_0, &mb[0]);
2253
2254         /* ASYNC data setup time. */
2255         mb[0] = MBC_SET_ASYNC_DATA_SETUP;
2256         mb[1] = nv->bus[0].config_2.async_data_setup_time;
2257         mb[2] = nv->bus[1].config_2.async_data_setup_time;
2258         status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2259
2260         /* Active negation states. */
2261         mb[0] = MBC_SET_ACTIVE_NEGATION;
2262         mb[1] = 0;
2263         if (nv->bus[0].config_2.req_ack_active_negation)
2264                 mb[1] |= BIT_5;
2265         if (nv->bus[0].config_2.data_line_active_negation)
2266                 mb[1] |= BIT_4;
2267         mb[2] = 0;
2268         if (nv->bus[1].config_2.req_ack_active_negation)
2269                 mb[2] |= BIT_5;
2270         if (nv->bus[1].config_2.data_line_active_negation)
2271                 mb[2] |= BIT_4;
2272         status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2273
2274         mb[0] = MBC_SET_DATA_OVERRUN_RECOVERY;
2275         mb[1] = 2;      /* Reset SCSI bus and return all outstanding IO */
2276         status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2277
2278         /* thingy */
2279         mb[0] = MBC_SET_PCI_CONTROL;
2280         mb[1] = BIT_1;  /* Data DMA Channel Burst Enable */
2281         mb[2] = BIT_1;  /* Command DMA Channel Burst Enable */
2282         status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2283
2284         mb[0] = MBC_SET_TAG_AGE_LIMIT;
2285         mb[1] = 8;
2286         status |= qla1280_mailbox_command(ha, BIT_1 | BIT_0, mb);
2287
2288         /* Selection timeout. */
2289         mb[0] = MBC_SET_SELECTION_TIMEOUT;
2290         mb[1] = nv->bus[0].selection_timeout;
2291         mb[2] = nv->bus[1].selection_timeout;
2292         status |= qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, mb);
2293
2294         for (bus = 0; bus < ha->ports; bus++)
2295                 status |= qla1280_config_bus(ha, bus);
2296
2297         if (status)
2298                 dprintk(2, "qla1280_nvram_config: **** FAILED ****\n");
2299
2300         LEAVE("qla1280_nvram_config");
2301         return status;
2302 }
2303
2304 /*
2305  * Get NVRAM data word
2306  *      Calculates word position in NVRAM and calls request routine to
2307  *      get the word from NVRAM.
2308  *
2309  * Input:
2310  *      ha      = adapter block pointer.
2311  *      address = NVRAM word address.
2312  *
2313  * Returns:
2314  *      data word.
2315  */
2316 static uint16_t
2317 qla1280_get_nvram_word(struct scsi_qla_host *ha, uint32_t address)
2318 {
2319         uint32_t nv_cmd;
2320         uint16_t data;
2321
2322         nv_cmd = address << 16;
2323         nv_cmd |= NV_READ_OP;
2324
2325         data = le16_to_cpu(qla1280_nvram_request(ha, nv_cmd));
2326
2327         dprintk(8, "qla1280_get_nvram_word: exiting normally NVRAM data = "
2328                 "0x%x", data);
2329
2330         return data;
2331 }
2332
2333 /*
2334  * NVRAM request
2335  *      Sends read command to NVRAM and gets data from NVRAM.
2336  *
2337  * Input:
2338  *      ha     = adapter block pointer.
2339  *      nv_cmd = Bit 26     = start bit
2340  *               Bit 25, 24 = opcode
2341  *               Bit 23-16  = address
2342  *               Bit 15-0   = write data
2343  *
2344  * Returns:
2345  *      data word.
2346  */
2347 static uint16_t
2348 qla1280_nvram_request(struct scsi_qla_host *ha, uint32_t nv_cmd)
2349 {
2350         struct device_reg __iomem *reg = ha->iobase;
2351         int cnt;
2352         uint16_t data = 0;
2353         uint16_t reg_data;
2354
2355         /* Send command to NVRAM. */
2356
2357         nv_cmd <<= 5;
2358         for (cnt = 0; cnt < 11; cnt++) {
2359                 if (nv_cmd & BIT_31)
2360                         qla1280_nv_write(ha, NV_DATA_OUT);
2361                 else
2362                         qla1280_nv_write(ha, 0);
2363                 nv_cmd <<= 1;
2364         }
2365
2366         /* Read data from NVRAM. */
2367
2368         for (cnt = 0; cnt < 16; cnt++) {
2369                 WRT_REG_WORD(&reg->nvram, (NV_SELECT | NV_CLOCK));
2370                 RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2371                 NVRAM_DELAY();
2372                 data <<= 1;
2373                 reg_data = RD_REG_WORD(&reg->nvram);
2374                 if (reg_data & NV_DATA_IN)
2375                         data |= BIT_0;
2376                 WRT_REG_WORD(&reg->nvram, NV_SELECT);
2377                 RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2378                 NVRAM_DELAY();
2379         }
2380
2381         /* Deselect chip. */
2382
2383         WRT_REG_WORD(&reg->nvram, NV_DESELECT);
2384         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2385         NVRAM_DELAY();
2386
2387         return data;
2388 }
2389
2390 static void
2391 qla1280_nv_write(struct scsi_qla_host *ha, uint16_t data)
2392 {
2393         struct device_reg __iomem *reg = ha->iobase;
2394
2395         WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2396         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2397         NVRAM_DELAY();
2398         WRT_REG_WORD(&reg->nvram, data | NV_SELECT | NV_CLOCK);
2399         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2400         NVRAM_DELAY();
2401         WRT_REG_WORD(&reg->nvram, data | NV_SELECT);
2402         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2403         NVRAM_DELAY();
2404 }
2405
2406 /*
2407  * Mailbox Command
2408  *      Issue mailbox command and waits for completion.
2409  *
2410  * Input:
2411  *      ha = adapter block pointer.
2412  *      mr = mailbox registers to load.
2413  *      mb = data pointer for mailbox registers.
2414  *
2415  * Output:
2416  *      mb[MAILBOX_REGISTER_COUNT] = returned mailbox data.
2417  *
2418  * Returns:
2419  *      0 = success
2420  */
2421 static int
2422 qla1280_mailbox_command(struct scsi_qla_host *ha, uint8_t mr, uint16_t *mb)
2423 {
2424         struct device_reg __iomem *reg = ha->iobase;
2425 #if 0
2426         LIST_HEAD(done_q);
2427 #endif
2428         int status = 0;
2429         int cnt;
2430         uint16_t *optr, *iptr;
2431         uint16_t __iomem *mptr;
2432         uint16_t data;
2433         DECLARE_COMPLETION(wait);
2434         struct timer_list timer;
2435
2436         ENTER("qla1280_mailbox_command");
2437
2438         if (ha->mailbox_wait) {
2439                 printk(KERN_ERR "Warning mailbox wait already in use!\n");
2440         }
2441         ha->mailbox_wait = &wait;
2442
2443         /*
2444          * We really should start out by verifying that the mailbox is
2445          * available before starting sending the command data
2446          */
2447         /* Load mailbox registers. */
2448         mptr = (uint16_t __iomem *) &reg->mailbox0;
2449         iptr = mb;
2450         for (cnt = 0; cnt < MAILBOX_REGISTER_COUNT; cnt++) {
2451                 if (mr & BIT_0) {
2452                         WRT_REG_WORD(mptr, (*iptr));
2453                 }
2454
2455                 mr >>= 1;
2456                 mptr++;
2457                 iptr++;
2458         }
2459
2460         /* Issue set host interrupt command. */
2461
2462         /* set up a timer just in case we're really jammed */
2463         init_timer(&timer);
2464         timer.expires = jiffies + 20*HZ;
2465         timer.data = (unsigned long)ha;
2466         timer.function = qla1280_mailbox_timeout;
2467         add_timer(&timer);
2468
2469         spin_unlock_irq(ha->host->host_lock);
2470         WRT_REG_WORD(&reg->host_cmd, HC_SET_HOST_INT);
2471         data = qla1280_debounce_register(&reg->istatus);
2472
2473         wait_for_completion(&wait);
2474         del_timer_sync(&timer);
2475
2476         spin_lock_irq(ha->host->host_lock);
2477
2478         ha->mailbox_wait = NULL;
2479
2480         /* Check for mailbox command timeout. */
2481         if (ha->mailbox_out[0] != MBS_CMD_CMP) {
2482                 printk(KERN_WARNING "qla1280_mailbox_command: Command failed, "
2483                        "mailbox0 = 0x%04x, mailbox_out0 = 0x%04x, istatus = "
2484                        "0x%04x\n", 
2485                        mb[0], ha->mailbox_out[0], RD_REG_WORD(&reg->istatus));
2486                 printk(KERN_WARNING "m0 %04x, m1 %04x, m2 %04x, m3 %04x\n",
2487                        RD_REG_WORD(&reg->mailbox0), RD_REG_WORD(&reg->mailbox1),
2488                        RD_REG_WORD(&reg->mailbox2), RD_REG_WORD(&reg->mailbox3));
2489                 printk(KERN_WARNING "m4 %04x, m5 %04x, m6 %04x, m7 %04x\n",
2490                        RD_REG_WORD(&reg->mailbox4), RD_REG_WORD(&reg->mailbox5),
2491                        RD_REG_WORD(&reg->mailbox6), RD_REG_WORD(&reg->mailbox7));
2492                 status = 1;
2493         }
2494
2495         /* Load return mailbox registers. */
2496         optr = mb;
2497         iptr = (uint16_t *) &ha->mailbox_out[0];
2498         mr = MAILBOX_REGISTER_COUNT;
2499         memcpy(optr, iptr, MAILBOX_REGISTER_COUNT * sizeof(uint16_t));
2500
2501 #if 0
2502         /* Go check for any response interrupts pending. */
2503         qla1280_isr(ha, &done_q);
2504 #endif
2505
2506         if (ha->flags.reset_marker)
2507                 qla1280_rst_aen(ha);
2508
2509 #if 0
2510         if (!list_empty(&done_q))
2511                 qla1280_done(ha, &done_q);
2512 #endif
2513
2514         if (status)
2515                 dprintk(2, "qla1280_mailbox_command: **** FAILED, mailbox0 = "
2516                         "0x%x ****\n", mb[0]);
2517
2518         LEAVE("qla1280_mailbox_command");
2519         return status;
2520 }
2521
2522 /*
2523  * qla1280_poll
2524  *      Polls ISP for interrupts.
2525  *
2526  * Input:
2527  *      ha = adapter block pointer.
2528  */
2529 static void
2530 qla1280_poll(struct scsi_qla_host *ha)
2531 {
2532         struct device_reg __iomem *reg = ha->iobase;
2533         uint16_t data;
2534         LIST_HEAD(done_q);
2535
2536         /* ENTER("qla1280_poll"); */
2537
2538         /* Check for pending interrupts. */
2539         data = RD_REG_WORD(&reg->istatus);
2540         if (data & RISC_INT)
2541                 qla1280_isr(ha, &done_q);
2542
2543         if (!ha->mailbox_wait) {
2544                 if (ha->flags.reset_marker)
2545                         qla1280_rst_aen(ha);
2546         }
2547
2548         if (!list_empty(&done_q))
2549                 qla1280_done(ha);
2550
2551         /* LEAVE("qla1280_poll"); */
2552 }
2553
2554 /*
2555  * qla1280_bus_reset
2556  *      Issue SCSI bus reset.
2557  *
2558  * Input:
2559  *      ha  = adapter block pointer.
2560  *      bus = SCSI bus number.
2561  *
2562  * Returns:
2563  *      0 = success
2564  */
2565 static int
2566 qla1280_bus_reset(struct scsi_qla_host *ha, int bus)
2567 {
2568         uint16_t mb[MAILBOX_REGISTER_COUNT];
2569         uint16_t reset_delay;
2570         int status;
2571
2572         dprintk(3, "qla1280_bus_reset: entered\n");
2573
2574         if (qla1280_verbose)
2575                 printk(KERN_INFO "scsi(%li:%i): Resetting SCSI BUS\n",
2576                        ha->host_no, bus);
2577
2578         reset_delay = ha->bus_settings[bus].bus_reset_delay;
2579         mb[0] = MBC_BUS_RESET;
2580         mb[1] = reset_delay;
2581         mb[2] = (uint16_t) bus;
2582         status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2583
2584         if (status) {
2585                 if (ha->bus_settings[bus].failed_reset_count > 2)
2586                         ha->bus_settings[bus].scsi_bus_dead = 1;
2587                 ha->bus_settings[bus].failed_reset_count++;
2588         } else {
2589                 spin_unlock_irq(ha->host->host_lock);
2590                 ssleep(reset_delay);
2591                 spin_lock_irq(ha->host->host_lock);
2592
2593                 ha->bus_settings[bus].scsi_bus_dead = 0;
2594                 ha->bus_settings[bus].failed_reset_count = 0;
2595                 ha->bus_settings[bus].reset_marker = 0;
2596                 /* Issue marker command. */
2597                 qla1280_marker(ha, bus, 0, 0, MK_SYNC_ALL);
2598         }
2599
2600         /*
2601          * We should probably call qla1280_set_target_parameters()
2602          * here as well for all devices on the bus.
2603          */
2604
2605         if (status)
2606                 dprintk(2, "qla1280_bus_reset: **** FAILED ****\n");
2607         else
2608                 dprintk(3, "qla1280_bus_reset: exiting normally\n");
2609
2610         return status;
2611 }
2612
2613 /*
2614  * qla1280_device_reset
2615  *      Issue bus device reset message to the target.
2616  *
2617  * Input:
2618  *      ha      = adapter block pointer.
2619  *      bus     = SCSI BUS number.
2620  *      target  = SCSI ID.
2621  *
2622  * Returns:
2623  *      0 = success
2624  */
2625 static int
2626 qla1280_device_reset(struct scsi_qla_host *ha, int bus, int target)
2627 {
2628         uint16_t mb[MAILBOX_REGISTER_COUNT];
2629         int status;
2630
2631         ENTER("qla1280_device_reset");
2632
2633         mb[0] = MBC_ABORT_TARGET;
2634         mb[1] = (bus ? (target | BIT_7) : target) << 8;
2635         mb[2] = 1;
2636         status = qla1280_mailbox_command(ha, BIT_2 | BIT_1 | BIT_0, &mb[0]);
2637
2638         /* Issue marker command. */
2639         qla1280_marker(ha, bus, target, 0, MK_SYNC_ID);
2640
2641         if (status)
2642                 dprintk(2, "qla1280_device_reset: **** FAILED ****\n");
2643
2644         LEAVE("qla1280_device_reset");
2645         return status;
2646 }
2647
2648 /*
2649  * qla1280_abort_device
2650  *      Issue an abort message to the device
2651  *
2652  * Input:
2653  *      ha     = adapter block pointer.
2654  *      bus    = SCSI BUS.
2655  *      target = SCSI ID.
2656  *      lun    = SCSI LUN.
2657  *
2658  * Returns:
2659  *      0 = success
2660  */
2661 static int
2662 qla1280_abort_device(struct scsi_qla_host *ha, int bus, int target, int lun)
2663 {
2664         uint16_t mb[MAILBOX_REGISTER_COUNT];
2665         int status;
2666
2667         ENTER("qla1280_abort_device");
2668
2669         mb[0] = MBC_ABORT_DEVICE;
2670         mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2671         status = qla1280_mailbox_command(ha, BIT_1 | BIT_0, &mb[0]);
2672
2673         /* Issue marker command. */
2674         qla1280_marker(ha, bus, target, lun, MK_SYNC_ID_LUN);
2675
2676         if (status)
2677                 dprintk(2, "qla1280_abort_device: **** FAILED ****\n");
2678
2679         LEAVE("qla1280_abort_device");
2680         return status;
2681 }
2682
2683 /*
2684  * qla1280_abort_command
2685  *      Abort command aborts a specified IOCB.
2686  *
2687  * Input:
2688  *      ha = adapter block pointer.
2689  *      sp = SB structure pointer.
2690  *
2691  * Returns:
2692  *      0 = success
2693  */
2694 static int
2695 qla1280_abort_command(struct scsi_qla_host *ha, struct srb * sp, int handle)
2696 {
2697         uint16_t mb[MAILBOX_REGISTER_COUNT];
2698         unsigned int bus, target, lun;
2699         int status;
2700
2701         ENTER("qla1280_abort_command");
2702
2703         bus = SCSI_BUS_32(sp->cmd);
2704         target = SCSI_TCN_32(sp->cmd);
2705         lun = SCSI_LUN_32(sp->cmd);
2706
2707         sp->flags |= SRB_ABORT_PENDING;
2708
2709         mb[0] = MBC_ABORT_COMMAND;
2710         mb[1] = (bus ? target | BIT_7 : target) << 8 | lun;
2711         mb[2] = handle >> 16;
2712         mb[3] = handle & 0xffff;
2713         status = qla1280_mailbox_command(ha, 0x0f, &mb[0]);
2714
2715         if (status) {
2716                 dprintk(2, "qla1280_abort_command: **** FAILED ****\n");
2717                 sp->flags &= ~SRB_ABORT_PENDING;
2718         }
2719
2720
2721         LEAVE("qla1280_abort_command");
2722         return status;
2723 }
2724
2725 /*
2726  * qla1280_reset_adapter
2727  *      Reset adapter.
2728  *
2729  * Input:
2730  *      ha = adapter block pointer.
2731  */
2732 static void
2733 qla1280_reset_adapter(struct scsi_qla_host *ha)
2734 {
2735         struct device_reg __iomem *reg = ha->iobase;
2736
2737         ENTER("qla1280_reset_adapter");
2738
2739         /* Disable ISP chip */
2740         ha->flags.online = 0;
2741         WRT_REG_WORD(&reg->ictrl, ISP_RESET);
2742         WRT_REG_WORD(&reg->host_cmd,
2743                      HC_RESET_RISC | HC_RELEASE_RISC | HC_DISABLE_BIOS);
2744         RD_REG_WORD(&reg->id_l);        /* Flush PCI write */
2745
2746         LEAVE("qla1280_reset_adapter");
2747 }
2748
2749 /*
2750  *  Issue marker command.
2751  *      Function issues marker IOCB.
2752  *
2753  * Input:
2754  *      ha   = adapter block pointer.
2755  *      bus  = SCSI BUS number
2756  *      id   = SCSI ID
2757  *      lun  = SCSI LUN
2758  *      type = marker modifier
2759  */
2760 static void
2761 qla1280_marker(struct scsi_qla_host *ha, int bus, int id, int lun, u8 type)
2762 {
2763         struct mrk_entry *pkt;
2764
2765         ENTER("qla1280_marker");
2766
2767         /* Get request packet. */
2768         if ((pkt = (struct mrk_entry *) qla1280_req_pkt(ha))) {
2769                 pkt->entry_type = MARKER_TYPE;
2770                 pkt->lun = (uint8_t) lun;
2771                 pkt->target = (uint8_t) (bus ? (id | BIT_7) : id);
2772                 pkt->modifier = type;
2773                 pkt->entry_status = 0;
2774
2775                 /* Issue command to ISP */
2776                 qla1280_isp_cmd(ha);
2777         }
2778
2779         LEAVE("qla1280_marker");
2780 }
2781
2782
2783 /*
2784  * qla1280_64bit_start_scsi
2785  *      The start SCSI is responsible for building request packets on
2786  *      request ring and modifying ISP input pointer.
2787  *
2788  * Input:
2789  *      ha = adapter block pointer.
2790  *      sp = SB structure pointer.
2791  *
2792  * Returns:
2793  *      0 = success, was able to issue command.
2794  */
2795 #ifdef QLA_64BIT_PTR
2796 static int
2797 qla1280_64bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
2798 {
2799         struct device_reg __iomem *reg = ha->iobase;
2800         struct scsi_cmnd *cmd = sp->cmd;
2801         cmd_a64_entry_t *pkt;
2802         struct scatterlist *sg = NULL;
2803         __le32 *dword_ptr;
2804         dma_addr_t dma_handle;
2805         int status = 0;
2806         int cnt;
2807         int req_cnt;
2808         u16 seg_cnt;
2809         u8 dir;
2810
2811         ENTER("qla1280_64bit_start_scsi:");
2812
2813         /* Calculate number of entries and segments required. */
2814         req_cnt = 1;
2815         if (cmd->use_sg) {
2816                 sg = (struct scatterlist *) cmd->request_buffer;
2817                 seg_cnt = pci_map_sg(ha->pdev, sg, cmd->use_sg,
2818                                      cmd->sc_data_direction);
2819
2820                 if (seg_cnt > 2) {
2821                         req_cnt += (seg_cnt - 2) / 5;
2822                         if ((seg_cnt - 2) % 5)
2823                                 req_cnt++;
2824                 }
2825         } else if (cmd->request_bufflen) {      /* If data transfer. */
2826                 seg_cnt = 1;
2827         } else {
2828                 seg_cnt = 0;
2829         }
2830
2831         if ((req_cnt + 2) >= ha->req_q_cnt) {
2832                 /* Calculate number of free request entries. */
2833                 cnt = RD_REG_WORD(&reg->mailbox4);
2834                 if (ha->req_ring_index < cnt)
2835                         ha->req_q_cnt = cnt - ha->req_ring_index;
2836                 else
2837                         ha->req_q_cnt =
2838                                 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
2839         }
2840
2841         dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
2842                 ha->req_q_cnt, seg_cnt);
2843
2844         /* If room for request in request ring. */
2845         if ((req_cnt + 2) >= ha->req_q_cnt) {
2846                 status = 1;
2847                 dprintk(2, "qla1280_start_scsi: in-ptr=0x%x  req_q_cnt="
2848                         "0x%xreq_cnt=0x%x", ha->req_ring_index, ha->req_q_cnt,
2849                         req_cnt);
2850                 goto out;
2851         }
2852
2853         /* Check for room in outstanding command list. */
2854         for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
2855                      ha->outstanding_cmds[cnt] != 0; cnt++);
2856
2857         if (cnt >= MAX_OUTSTANDING_COMMANDS) {
2858                 status = 1;
2859                 dprintk(2, "qla1280_start_scsi: NO ROOM IN "
2860                         "OUTSTANDING ARRAY, req_q_cnt=0x%x", ha->req_q_cnt);
2861                 goto out;
2862         }
2863
2864         ha->outstanding_cmds[cnt] = sp;
2865         ha->req_q_cnt -= req_cnt;
2866         CMD_HANDLE(sp->cmd) = (unsigned char *)(unsigned long)(cnt + 1);
2867
2868         dprintk(2, "start: cmd=%p sp=%p CDB=%xm, handle %lx\n", cmd, sp,
2869                 cmd->cmnd[0], (long)CMD_HANDLE(sp->cmd));
2870         dprintk(2, "             bus %i, target %i, lun %i\n",
2871                 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
2872         qla1280_dump_buffer(2, cmd->cmnd, MAX_COMMAND_SIZE);
2873
2874         /*
2875          * Build command packet.
2876          */
2877         pkt = (cmd_a64_entry_t *) ha->request_ring_ptr;
2878
2879         pkt->entry_type = COMMAND_A64_TYPE;
2880         pkt->entry_count = (uint8_t) req_cnt;
2881         pkt->sys_define = (uint8_t) ha->req_ring_index;
2882         pkt->entry_status = 0;
2883         pkt->handle = cpu_to_le32(cnt);
2884
2885         /* Zero out remaining portion of packet. */
2886         memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
2887
2888         /* Set ISP command timeout. */
2889         pkt->timeout = cpu_to_le16(30);
2890
2891         /* Set device target ID and LUN */
2892         pkt->lun = SCSI_LUN_32(cmd);
2893         pkt->target = SCSI_BUS_32(cmd) ?
2894                 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
2895
2896         /* Enable simple tag queuing if device supports it. */
2897         if (cmd->device->simple_tags)
2898                 pkt->control_flags |= cpu_to_le16(BIT_3);
2899
2900         /* Load SCSI command packet. */
2901         pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
2902         memcpy(pkt->scsi_cdb, &(CMD_CDBP(cmd)), CMD_CDBLEN(cmd));
2903         /* dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
2904
2905         /* Set transfer direction. */
2906         dir = qla1280_data_direction(cmd);
2907         pkt->control_flags |= cpu_to_le16(dir);
2908
2909         /* Set total data segment count. */
2910         pkt->dseg_count = cpu_to_le16(seg_cnt);
2911
2912         /*
2913          * Load data segments.
2914          */
2915         if (seg_cnt) {  /* If data transfer. */
2916                 /* Setup packet address segment pointer. */
2917                 dword_ptr = (u32 *)&pkt->dseg_0_address;
2918
2919                 if (cmd->use_sg) {      /* If scatter gather */
2920                         /* Load command entry data segments. */
2921                         for (cnt = 0; cnt < 2 && seg_cnt; cnt++, seg_cnt--) {
2922                                 dma_handle = sg_dma_address(sg);
2923 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2924                                 if (ha->flags.use_pci_vchannel)
2925                                         sn_pci_set_vchan(ha->pdev,
2926                                                         (unsigned long *)&dma_handle,
2927                                                          SCSI_BUS_32(cmd));
2928 #endif
2929                                 *dword_ptr++ =
2930                                         cpu_to_le32(pci_dma_lo32(dma_handle));
2931                                 *dword_ptr++ =
2932                                         cpu_to_le32(pci_dma_hi32(dma_handle));
2933                                 *dword_ptr++ = cpu_to_le32(sg_dma_len(sg));
2934                                 sg++;
2935                                 dprintk(3, "S/G Segment phys_addr=%x %x, len=0x%x\n",
2936                                         cpu_to_le32(pci_dma_hi32(dma_handle)),
2937                                         cpu_to_le32(pci_dma_lo32(dma_handle)),
2938                                         cpu_to_le32(sg_dma_len(sg)));
2939                         }
2940                         dprintk(5, "qla1280_64bit_start_scsi: Scatter/gather "
2941                                 "command packet data - b %i, t %i, l %i \n",
2942                                 SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
2943                                 SCSI_LUN_32(cmd));
2944                         qla1280_dump_buffer(5, (char *)pkt,
2945                                             REQUEST_ENTRY_SIZE);
2946
2947                         /*
2948                          * Build continuation packets.
2949                          */
2950                         dprintk(3, "S/G Building Continuation...seg_cnt=0x%x "
2951                                 "remains\n", seg_cnt);
2952
2953                         while (seg_cnt > 0) {
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 (cnt = 0; cnt < 5 && seg_cnt;
2980                                      cnt++, seg_cnt--) {
2981                                         dma_handle = sg_dma_address(sg);
2982 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
2983                                 if (ha->flags.use_pci_vchannel)
2984                                         sn_pci_set_vchan(ha->pdev, 
2985                                                         (unsigned long *)&dma_handle,
2986                                                          SCSI_BUS_32(cmd));
2987 #endif
2988                                         *dword_ptr++ =
2989                                                 cpu_to_le32(pci_dma_lo32(dma_handle));
2990                                         *dword_ptr++ =
2991                                                 cpu_to_le32(pci_dma_hi32(dma_handle));
2992                                         *dword_ptr++ =
2993                                                 cpu_to_le32(sg_dma_len(sg));
2994                                         dprintk(3, "S/G Segment Cont. phys_addr=%x %x, len=0x%x\n",
2995                                                 cpu_to_le32(pci_dma_hi32(dma_handle)),
2996                                                 cpu_to_le32(pci_dma_lo32(dma_handle)),
2997                                                 cpu_to_le32(sg_dma_len(sg)));
2998                                         sg++;
2999                                 }
3000                                 dprintk(5, "qla1280_64bit_start_scsi: "
3001                                         "continuation packet data - b %i, t "
3002                                         "%i, l %i \n", SCSI_BUS_32(cmd),
3003                                         SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3004                                 qla1280_dump_buffer(5, (char *)pkt,
3005                                                     REQUEST_ENTRY_SIZE);
3006                         }
3007                 } else {        /* No scatter gather data transfer */
3008                         dma_handle = pci_map_single(ha->pdev,
3009                                         cmd->request_buffer,
3010                                         cmd->request_bufflen,
3011                                         cmd->sc_data_direction);
3012
3013                         sp->saved_dma_handle = dma_handle;
3014 #if defined(CONFIG_IA64_GENERIC) || defined(CONFIG_IA64_SGI_SN2)
3015                         if (ha->flags.use_pci_vchannel)
3016                                 sn_pci_set_vchan(ha->pdev, 
3017                                                 (unsigned long *)&dma_handle,
3018                                                  SCSI_BUS_32(cmd));
3019 #endif
3020                         *dword_ptr++ = cpu_to_le32(pci_dma_lo32(dma_handle));
3021                         *dword_ptr++ = cpu_to_le32(pci_dma_hi32(dma_handle));
3022                         *dword_ptr = cpu_to_le32(cmd->request_bufflen);
3023
3024                         dprintk(5, "qla1280_64bit_start_scsi: No scatter/"
3025                                 "gather command packet data - b %i, t %i, "
3026                                 "l %i \n", SCSI_BUS_32(cmd), SCSI_TCN_32(cmd),
3027                                 SCSI_LUN_32(cmd));
3028                         qla1280_dump_buffer(5, (char *)pkt,
3029                                             REQUEST_ENTRY_SIZE);
3030                 }
3031         } else {        /* No data transfer */
3032                 dprintk(5, "qla1280_64bit_start_scsi: No data, command "
3033                         "packet data - b %i, t %i, l %i \n",
3034                         SCSI_BUS_32(cmd), SCSI_TCN_32(cmd), SCSI_LUN_32(cmd));
3035                 qla1280_dump_buffer(5, (char *)pkt, REQUEST_ENTRY_SIZE);
3036         }
3037         /* Adjust ring index. */
3038         ha->req_ring_index++;
3039         if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3040                 ha->req_ring_index = 0;
3041                 ha->request_ring_ptr = ha->request_ring;
3042         } else
3043                 ha->request_ring_ptr++;
3044
3045         /* Set chip new ring index. */
3046         dprintk(2,
3047                 "qla1280_64bit_start_scsi: Wakeup RISC for pending command\n");
3048         sp->flags |= SRB_SENT;
3049         ha->actthreads++;
3050         WRT_REG_WORD(&reg->mailbox4, ha->req_ring_index);
3051         /* Enforce mmio write ordering; see comment in qla1280_isp_cmd(). */
3052         mmiowb();
3053
3054  out:
3055         if (status)
3056                 dprintk(2, "qla1280_64bit_start_scsi: **** FAILED ****\n");
3057         else
3058                 dprintk(3, "qla1280_64bit_start_scsi: exiting normally\n");
3059
3060         return status;
3061 }
3062 #else /* !QLA_64BIT_PTR */
3063
3064 /*
3065  * qla1280_32bit_start_scsi
3066  *      The start SCSI is responsible for building request packets on
3067  *      request ring and modifying ISP input pointer.
3068  *
3069  *      The Qlogic firmware interface allows every queue slot to have a SCSI
3070  *      command and up to 4 scatter/gather (SG) entries.  If we need more
3071  *      than 4 SG entries, then continuation entries are used that can
3072  *      hold another 7 entries each.  The start routine determines if there
3073  *      is eought empty slots then build the combination of requests to
3074  *      fulfill the OS request.
3075  *
3076  * Input:
3077  *      ha = adapter block pointer.
3078  *      sp = SCSI Request Block structure pointer.
3079  *
3080  * Returns:
3081  *      0 = success, was able to issue command.
3082  */
3083 static int
3084 qla1280_32bit_start_scsi(struct scsi_qla_host *ha, struct srb * sp)
3085 {
3086         struct device_reg __iomem *reg = ha->iobase;
3087         struct scsi_cmnd *cmd = sp->cmd;
3088         struct cmd_entry *pkt;
3089         struct scatterlist *sg = NULL;
3090         __le32 *dword_ptr;
3091         int status = 0;
3092         int cnt;
3093         int req_cnt;
3094         uint16_t seg_cnt;
3095         dma_addr_t dma_handle;
3096         u8 dir;
3097
3098         ENTER("qla1280_32bit_start_scsi");
3099
3100         dprintk(1, "32bit_start: cmd=%p sp=%p CDB=%x\n", cmd, sp,
3101                 cmd->cmnd[0]);
3102
3103         /* Calculate number of entries and segments required. */
3104         req_cnt = 1;
3105         if (cmd->use_sg) {
3106                 /*
3107                  * We must build an SG list in adapter format, as the kernel's
3108                  * SG list cannot be used directly because of data field size
3109                  * (__alpha__) differences and the kernel SG list uses virtual
3110                  * addresses where we need physical addresses.
3111                  */
3112                 sg = (struct scatterlist *) cmd->request_buffer;
3113                 seg_cnt = pci_map_sg(ha->pdev, sg, cmd->use_sg,
3114                                      cmd->sc_data_direction);
3115
3116                 /*
3117                  * if greater than four sg entries then we need to allocate
3118                  * continuation entries
3119                  */
3120                 if (seg_cnt > 4) {
3121                         req_cnt += (seg_cnt - 4) / 7;
3122                         if ((seg_cnt - 4) % 7)
3123                                 req_cnt++;
3124                 }
3125                 dprintk(3, "S/G Transfer cmd=%p seg_cnt=0x%x, req_cnt=%x\n",
3126                         cmd, seg_cnt, req_cnt);
3127         } else if (cmd->request_bufflen) {      /* If data transfer. */
3128                 dprintk(3, "No S/G transfer t=%x cmd=%p len=%x CDB=%x\n",
3129                         SCSI_TCN_32(cmd), cmd, cmd->request_bufflen,
3130                         cmd->cmnd[0]);
3131                 seg_cnt = 1;
3132         } else {
3133                 /* dprintk(1, "No data transfer \n"); */
3134                 seg_cnt = 0;
3135         }
3136
3137         if ((req_cnt + 2) >= ha->req_q_cnt) {
3138                 /* Calculate number of free request entries. */
3139                 cnt = RD_REG_WORD(&reg->mailbox4);
3140                 if (ha->req_ring_index < cnt)
3141                         ha->req_q_cnt = cnt - ha->req_ring_index;
3142                 else
3143                         ha->req_q_cnt =
3144                                 REQUEST_ENTRY_CNT - (ha->req_ring_index - cnt);
3145         }
3146
3147         dprintk(3, "Number of free entries=(%d) seg_cnt=0x%x\n",
3148                 ha->req_q_cnt, seg_cnt);
3149         /* If room for request in request ring. */
3150         if ((req_cnt + 2) >= ha->req_q_cnt) {
3151                 status = 1;
3152                 dprintk(2, "qla1280_32bit_start_scsi: in-ptr=0x%x, "
3153                         "req_q_cnt=0x%x, req_cnt=0x%x", ha->req_ring_index,
3154                         ha->req_q_cnt, req_cnt);
3155                 goto out;
3156         }
3157
3158         /* Check for empty slot in outstanding command list. */
3159         for (cnt = 0; cnt < MAX_OUTSTANDING_COMMANDS &&
3160                      (ha->outstanding_cmds[cnt] != 0); cnt++) ;
3161
3162         if (cnt >= MAX_OUTSTANDING_COMMANDS) {
3163                 status = 1;
3164                 dprintk(2, "qla1280_32bit_start_scsi: NO ROOM IN OUTSTANDING "
3165                         "ARRAY, req_q_cnt=0x%x\n", ha->req_q_cnt);
3166                 goto out;
3167         }
3168
3169         CMD_HANDLE(sp->cmd) = (unsigned char *) (unsigned long)(cnt + 1);
3170         ha->outstanding_cmds[cnt] = sp;
3171         ha->req_q_cnt -= req_cnt;
3172
3173         /*
3174          * Build command packet.
3175          */
3176         pkt = (struct cmd_entry *) ha->request_ring_ptr;
3177
3178         pkt->entry_type = COMMAND_TYPE;
3179         pkt->entry_count = (uint8_t) req_cnt;
3180         pkt->sys_define = (uint8_t) ha->req_ring_index;
3181         pkt->entry_status = 0;
3182         pkt->handle = cpu_to_le32(cnt);
3183
3184         /* Zero out remaining portion of packet. */
3185         memset(((char *)pkt + 8), 0, (REQUEST_ENTRY_SIZE - 8));
3186
3187         /* Set ISP command timeout. */
3188         pkt->timeout = cpu_to_le16(30);
3189
3190         /* Set device target ID and LUN */
3191         pkt->lun = SCSI_LUN_32(cmd);
3192         pkt->target = SCSI_BUS_32(cmd) ?
3193                 (SCSI_TCN_32(cmd) | BIT_7) : SCSI_TCN_32(cmd);
3194
3195         /* Enable simple tag queuing if device supports it. */
3196         if (cmd->device->simple_tags)
3197                 pkt->control_flags |= cpu_to_le16(BIT_3);
3198
3199         /* Load SCSI command packet. */
3200         pkt->cdb_len = cpu_to_le16(CMD_CDBLEN(cmd));
3201         memcpy(pkt->scsi_cdb, &(CMD_CDBP(cmd)), CMD_CDBLEN(cmd));
3202
3203         /*dprintk(1, "Build packet for command[0]=0x%x\n",pkt->scsi_cdb[0]); */
3204         /* Set transfer direction. */
3205         dir = qla1280_data_direction(cmd);
3206         pkt->control_flags |= cpu_to_le16(dir);
3207
3208         /* Set total data segment count. */
3209         pkt->dseg_count = cpu_to_le16(seg_cnt);
3210
3211         /*
3212          * Load data segments.
3213          */
3214         if (seg_cnt) {
3215                 /* Setup packet address segment pointer. */
3216                 dword_ptr = &pkt->dseg_0_address;
3217
3218                 if (cmd->use_sg) {      /* If scatter gather */
3219                         dprintk(3, "Building S/G data segments..\n");
3220                         qla1280_dump_buffer(1, (char *)sg, 4 * 16);
3221
3222                         /* Load command entry data segments. */
3223                         for (cnt = 0; cnt < 4 && seg_cnt; cnt++, seg_cnt--) {
3224                                 *dword_ptr++ =
3225                                         cpu_to_le32(pci_dma_lo32(sg_dma_address(sg)));
3226                                 *dword_ptr++ =
3227                                         cpu_to_le32(sg_dma_len(sg));
3228                                 dprintk(3, "S/G Segment phys_addr=0x%lx, len=0x%x\n",
3229                                         (pci_dma_lo32(sg_dma_address(sg))),
3230                                         (sg_dma_len(sg)));
3231                                 sg++;
3232                         }
3233                         /*
3234                          * Build continuation packets.
3235                          */
3236                         dprintk(3, "S/G Building Continuation"
3237                                 "...seg_cnt=0x%x remains\n", seg_cnt);
3238                         while (seg_cnt > 0) {
3239                                 /* Adjust ring index. */
3240                                 ha->req_ring_index++;
3241                                 if (ha->req_ring_index == REQUEST_ENTRY_CNT) {
3242                                         ha->req_ring_index = 0;
3243                                         ha->request_ring_ptr =
3244                                                 ha->request_ring;
3245                                 } else
3246                                         ha->request_ring_ptr++;
3247
3248                                 pkt = (struct cmd_entry *)ha->request_ring_ptr;
3249
3250                                 /* Zero out packet. */
3251                                 memset(pkt, 0, REQUEST_ENTRY_SIZE);
3252
3253                                 /* Load packet defaults. */
3254                                 ((struct cont_entry *) pkt)->
3255                                         entry_type = CONTINUE_TYPE;
3256                                 ((struct cont_entry *) pkt)->entry_count = 1;
3257
3258                                 ((struct cont_entry *) pkt)->sys_define =
3259                                         (uint8_t) ha->req_ring_index;
3260
3261                                 /* Setup packet address segment pointer. */
3262                                 dword_ptr =
3263                                         &((struct cont_entry *) pkt)->dseg_0_address;
3264
3265                                 /* Load continuation entry data segments. */
3266                                 for (cnt = 0; cnt < 7 && seg_cnt;
3267                                      cnt++, seg_cnt--) {
3268                                         *dword_ptr++ =
3269                                                 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg)));
3270                                         *dword_ptr++ =
3271                                                 cpu_to_le32(sg_dma_len(sg));
3272                                         dprintk(1,
3273                                                 "S/G Segment Cont. phys_addr=0x%x, "
3274                                                 "len=0x%x\n",
3275                                                 cpu_to_le32(pci_dma_lo32(sg_dma_address(sg))),
3276                                                 cpu_to_le32(sg_dma_len(sg)));
3277                                         sg++;
3278                                 }
3279              &n