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