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