Force some semblance of workingness onto qla1280 driver
[opensuse:kernel.git] / drivers / scsi / qla1280.c
1 /********************************************************************************
2  *                  QLOGIC LINUX SOFTWARE
3  *
4  * QLogic ISP1x80/1x160 device driver for Linux 2.3.x (redhat 6.X).
5  *
6  * COPYRIGHT (C) 1999-2000 QLOGIC CORPORATION    
7  *
8  * This program is free software; you can redistribute it and/or modify
9  * it under the terms of the Qlogic's Linux Software License. See below.
10  *
11  * This program is WITHOUT ANY WARRANTY; without even the implied warranty of
12  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  
13  *
14  * Redistribution and use in source and binary forms, with or without
15  * modification, are permitted provided that the following conditions
16  * are met:
17  *
18  * 1. Redistribution's or source code must retain the above copyright
19  *    notice, this list of conditions, and the following disclaimer,
20  *    without modification, immediately at the beginning of the file.
21  * 2. The name of the author may not be used to endorse or promote products
22  *    derived from this software without specific prior written permission.
23  *
24  ********************************************************************************/
25  
26 /*****************************************************************************************
27                         QLOGIC CORPORATION SOFTWARE
28            "GNU" GENERAL PUBLIC LICENSE
29     TERMS AND CONDITIONS FOR COPYING, DISTRIBUTION
30                  AND MODIFICATION
31
32 This GNU General Public License ("License") applies solely to QLogic Linux 
33 Software ("Software") and may be distributed under the terms of this License.  
34  
35 1. You may copy and distribute verbatim copies of the Software's source code as 
36 you receive it, in any medium, provided that you conspicuously and appropriately 
37 publish on each copy an appropriate copyright notice and disclaimer of warranty;
38 keep intact all the notices that refer to this License and to the absence of any
39 warranty; and give any other recipients of the Software a copy of this License along
40 with the Software. 
41
42 You may charge a fee for the physical act of transferring a copy, and you may at your
43 option offer warranty protection in exchange for a fee.
44  
45 2. You may modify your copy or copies of the Software or any portion of it, thus forming
46 a work based on the Software, and copy and distribute such modifications or work under
47 the terms of Section 1 above, provided that you also meet all of these conditions:
48  
49 * a) You must cause the modified files to carry prominent notices stating that you
50 changed the files and the date of any change. 
51
52 * b) You must cause any work that you distribute or publish that in whole or in part
53 contains or is derived from the Software or any part thereof, to be licensed as a
54 whole at no charge to all third parties under the terms of this License. 
55
56 * c) If the modified Software normally reads commands interactively when run, you
57 must cause it, when started running for such interactive use in the most ordinary way,
58 to print or display an announcement including an appropriate copyright notice and a 
59 notice that there is no warranty (or else, saying that you provide a warranty) and that
60 users may redistribute the Software under these conditions, and telling the user how to
61 view a copy of this License. (Exception:if the Software itself is interactive but does 
62 not normally print such an announcement, your work based on the Software is not required
63 to print an announcement.) 
64
65 These requirements apply to the modified work as a whole. If identifiable sections of
66 that work are not derived from the Software, and can be reasonably considered independent
67 and separate works in themselves, then this License, and its terms, do not apply to those
68 sections when you distribute them as separate works. But when you distribute the same
69 sections as part of a whole which is a work based on the Software, the distribution of the
70 whole must be on the terms of this License, whose permissions for other licensees extend
71 to the entire whole, and thus to each and every part regardless of who wrote it. 
72
73 3. You may copy and distribute the Software (or a work based on it, under Section 2) in 
74 object code or executable form under the terms of Sections 1 and 2 above provided that
75 you also do one of the following: 
76
77 * a) Accompany it with the complete corresponding machine-readable source code, which must
78 be distributed under the terms of Sections 1 and 2 above on a medium customarily used for
79 software interchange; or, 
80
81 * b) Accompany it with a written offer, valid for at least three years, to give any third
82 party, for a charge no more than your cost of physically performing source distribution,
83 a complete machine-readable copy of the corresponding source code, to be distributed under
84 the terms of Sections 1 and 2 above on a medium customarily used for software interchange;
85 or,
86
87 * c) Accompany it with the information you received as to the offer to distribute 
88 corresponding source code. (This alternative is allowed only for noncommercial distribution
89 and only if you received the Software in object code or executable form with such an offer,
90 in accord with Subsection b above.) 
91
92 The source code for a work means the preferred form of the work for making modifications
93 to it. For an executable work, complete source code means all the source code for all 
94 modules it contains, plus any associated interface definition files, plus the scripts used
95 to control compilation and installation of the executable.     
96
97 If distribution of executable or object code is made by offering access to copy from a 
98 designated place, then offering equivalent access to copy the source code from the same
99 place counts as distribution of the source code, even though third parties are not 
100 compelled to copy the source along with the object code. 
101
102 4. You may not copy, modify, sublicense, or distribute the Software except as expressly 
103 provided under this License. Any attempt otherwise to copy, modify, sublicense or 
104 distribute the Software is void, and will automatically terminate your rights under this
105 License. However, parties who have received copies, or rights, from you under this License
106 will not have their licenses terminated so long as such parties remain in full compliance. 
107
108 5. This license grants you world wide, royalty free non-exclusive rights to modify or 
109 distribute the Software or its derivative works. These actions are prohibited by law 
110 if you do not accept this License. Therefore, by modifying or distributing the Software
111 (or any work based on the Software), you indicate your acceptance of this License to do
112 so, and all its terms and conditions for copying, distributing or modifying the Software
113 or works based on it.
114  
115 6. Each time you redistribute the Software (or any work based on the Software), the 
116 recipient automatically receives a license from the original licensor to copy, distribute
117 or modify the Software subject to these terms and conditions. You may not impose any 
118 further restrictions on the recipients' exercise of the rights granted herein. You are
119 not responsible for enforcing compliance by third parties to this License.
120  
121 7. If, as a consequence of a court judgment or allegation of patent infringement or for
122 any other reason (not limited to patent issues), conditions are imposed on you 
123 (whether by court order, agreement or otherwise) that contradict the conditions of this
124 License, they do not excuse you from the conditions of this License. If you cannot 
125 distribute so as to satisfy simultaneously your obligations under this License 
126 and any other pertinent obligations, then as a consequence you may not distribute the
127 Software at all.    
128
129 If any portion of this section is held invalid or unenforceable under any particular 
130 circumstance, the balance of the section is intended to apply and the section as a whole
131 is intended to apply in other circumstances. 
132 NO WARRANTY
133
134 11. THE SOFTWARE IS PROVIDED WITHOUT A WARRANTY OF ANY KIND. THERE IS NO 
135 WARRANTY FOR THE SOFTWARE, TO THE EXTENT PERMITTED BY APPLICABLE LAW. 
136 EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT HOLDERS AND/OR 
137 OTHER PARTIES PROVIDE THE SOFTWARE "AS IS" WITHOUT WARRANTY OF ANY KIND, 
138 EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED 
139 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE. THE 
140 ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE SOFTWARE IS WITH YOU. 
141 SHOULD THE SOFTWARE PROVE DEFECTIVE, YOU ASSUME THE COST OF ALL 
142 NECESSARY SERVICING, REPAIR OR CORRECTION.
143  
144 12. IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING 
145 WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MAY MODIFY AND/OR 
146 REDISTRIBUTE THE SOFTWARE AS PERMITTED ABOVE, BE LIABLE TO YOU FOR 
147 DAMAGES, INCLUDING ANY GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL 
148 DAMAGES ARISING OUT OF THE USE OR INABILITY TO USE THE SOFTWARE (INCLUDING 
149 BUT NOT LIMITED TO LOSS OF DATA OR DATA BEING RENDERED INACCURATE OR 
150 LOSSES SUSTAINED BY YOU OR THIRD PARTIES OR A FAILURE OF THE SOFTWARE TO 
151 OPERATE WITH ANY OTHER SOFTWARES), EVEN IF SUCH HOLDER OR OTHER PARTY HAS 
152 BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGES. 
153 END OF TERMS AND CONDITIONS 
154
155 *******************************************************************************************/ 
156
157 /****************************************************************************
158     Revision History:
159     Rev. 3.00       Jan 17, 1999    DG  Qlogic
160            - Added 64-bit support.
161     Rev. 2.07       Nov 9, 1999     DG  Qlogic
162            - Added new routine to set target parameters for ISP12160. 
163     Rev. 2.06       Sept 10, 1999     DG  Qlogic
164        - Added support for ISP12160 Ultra 3 chip.
165     Rev. 2.03       August 3, 1999    Fred Lewis, Intel DuPont
166         - Modified code to remove errors generated when compiling with
167           Cygnus IA64 Compiler.
168         - Changed conversion of pointers to unsigned longs instead of integers.
169         - Changed type of I/O port variables from uint32_t to unsigned long.
170         - Modified OFFSET macro to work with 64-bit as well as 32-bit.
171         - Changed sprintf and printk format specifiers for pointers to %p.
172         - Changed some int to long type casts where needed in sprintf & printk.
173         - Added l modifiers to sprintf and printk format specifiers for longs.
174         - Removed unused local variables.
175     Rev. 1.20       June 8, 1999      DG,  Qlogic
176          Changes to support RedHat release 6.0 (kernel 2.2.5).  
177        - Added SCSI exclusive access lock (io_request_lock) when accessing 
178          the adapter.
179        - Added changes for the new LINUX interface template. Some new error
180          handling routines have been added to the template, but for now we
181          will use the old ones.
182     -   Initial Beta Release.  
183 *****************************************************************************/
184
185 #include <linux/module.h>
186
187 #define QLA1280_VERSION      " 3.00-Beta"
188
189 #include <stdarg.h>
190 #include <asm/io.h>
191 #include <asm/irq.h>
192 #include <asm/byteorder.h>
193 #include <linux/version.h>
194 #include <linux/types.h>
195 #include <linux/string.h>
196 #include <linux/errno.h>
197 #include <linux/kernel.h>
198 #include <linux/ioport.h>
199 #include <linux/delay.h>
200 #include <linux/timer.h>
201 #include <linux/sched.h>
202 #include <linux/pci.h>
203 #include <linux/proc_fs.h>
204 #include <linux/blk.h>
205 #include <linux/tqueue.h>
206 /* MRS #include <linux/tasks.h> */
207 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
208 # include <linux/bios32.h>
209 #endif
210 #include "sd.h"
211 #include "scsi.h"
212 #include "hosts.h"
213 #define UNIQUE_FW_NAME
214 #include "qla1280.h"
215 #include "ql12160_fw.h"                     /* ISP RISC code */
216 #include "ql1280_fw.h"
217
218 #include <linux/stat.h>
219 #include <linux/slab.h>        /* for kmalloc() */
220
221
222 #ifndef KERNEL_VERSION
223 #  define KERNEL_VERSION(x,y,z) (((x)<<16)+((y)<<8)+(z))
224 #endif
225
226
227 /*
228  * Compile time Options: 
229  *            0 - Disable and 1 - Enable 
230  */
231 #define  QLA1280_64BIT_SUPPORT         1   /* 64-bit Support */
232 #define  QL1280_TARGET_MODE_SUPPORT    0   /* Target mode support */
233 #define  WATCHDOGTIMER                 0
234 #define  MEMORY_MAPPED_IO              0
235 #define  DEBUG_QLA1280_INTR            0
236 #define  USE_NVRAM_DEFAULTS            0
237 #define  DEBUG_PRINT_NVRAM             0
238 #define  LOADING_RISC_ACTIVITY         0
239 #define  AUTO_ESCALATE_RESET           0   /* Automatically escalate resets */
240 #define  AUTO_ESCALATE_ABORT           0   /* Automatically escalate aborts */
241 #define  STOP_ON_ERROR                 0   /* Stop on aborts and resets  */
242 #define  STOP_ON_RESET                 0 
243 #define  STOP_ON_ABORT                 0 
244 #undef   DYNAMIC_MEM_ALLOC
245
246 #define  DEBUG_QLA1280                 0    /* Debugging  */
247 /* #define CHECKSRBSIZE */
248
249 /*
250  * These macros to assist programming
251  */
252
253 #define BZERO(ptr, amt)         memset(ptr, 0, amt)
254 #define BCOPY(src, dst, amt)    memcpy(dst, src, amt)
255 #define KMALLOC(siz)    kmalloc((siz), GFP_ATOMIC)
256 #define KMFREE(ip,siz)  kfree((ip))
257 #define SYS_DELAY(x)            udelay(x);barrier()
258 #define QLA1280_DELAY(sec)  mdelay(sec * 1000)
259 #define VIRT_TO_BUS(a) virt_to_bus((a))
260 #if  QLA1280_64BIT_SUPPORT
261 #if  BITS_PER_LONG <= 32
262 #define  VIRT_TO_BUS_LOW(a) (uint32_t)virt_to_bus((a))
263 #define  VIRT_TO_BUS_HIGH(a) (uint32_t)(0x0)
264 #else
265 #define  VIRT_TO_BUS_LOW(a) (uint32_t)(0xffffffff & virt_to_bus((a)))
266 #define  VIRT_TO_BUS_HIGH(a) (uint32_t)(0xffffffff & (virt_to_bus((a))>>32))
267 #endif
268 #endif  /* QLA1280_64BIT_SUPPORT */
269
270 #define STATIC     
271
272 #define NVRAM_DELAY() udelay(500) /* 2 microsecond delay */
273 void qla1280_device_queue_depth(scsi_qla_host_t *, Scsi_Device *);
274
275 #define  CACHE_FLUSH(a) (RD_REG_WORD(a))
276 #define  INVALID_HANDLE    (MAX_OUTSTANDING_COMMANDS+1)
277
278 #define  MSW(x)          (uint16_t)((uint32_t)(x) >> 16)
279 #define  LSW(x)          (uint16_t)(x)
280 #define  MSB(x)          (uint8_t)((uint16_t)(x) >> 8)
281 #define  LSB(x)          (uint8_t)(x)
282
283 #if  BITS_PER_LONG <= 32
284 #define  LS_64BITS(x) (uint32_t)(x)
285 #define  MS_64BITS(x) (uint32_t)(0x0)
286 #else
287 #define  LS_64BITS(x) (uint32_t)(0xffffffff & (x))
288 #define  MS_64BITS(x) (uint32_t)(0xffffffff & ((x)>>32) )
289 #endif
290
291 /*
292  *  QLogic Driver Support Function Prototypes.
293  */
294 STATIC void   qla1280_done(scsi_qla_host_t *, srb_t **, srb_t **);
295 STATIC void   qla1280_next(scsi_qla_host_t *, scsi_lu_t *, uint8_t);
296 STATIC void   qla1280_putq_t(scsi_lu_t *, srb_t *);
297 STATIC void   qla1280_done_q_put(srb_t *, srb_t **, srb_t **);
298 STATIC void qla1280_select_queue_depth(struct Scsi_Host *, Scsi_Device *);
299 #ifdef  QLA1280_UNUSED 
300 static void qla1280_dump_regs(struct Scsi_Host *host);
301 #endif
302 #if  STOP_ON_ERROR 
303 static void qla1280_panic(char *, struct Scsi_Host *host);
304 #endif
305 void qla1280_print_scsi_cmd(Scsi_Cmnd *cmd);
306 STATIC void qla1280_abort_queue_single(scsi_qla_host_t *,uint32_t,uint32_t,uint32_t,uint32_t);
307
308 STATIC int qla1280_return_status( sts_entry_t *sts, Scsi_Cmnd       *cp);
309 STATIC void qla1280_removeq(scsi_lu_t *q, srb_t *sp);
310 STATIC void qla1280_mem_free(scsi_qla_host_t *ha);
311 static void qla1280_do_dpc(void *p);
312 #ifdef  QLA1280_UNUSED 
313 static void qla1280_set_flags(char * s);
314 #endif
315 static char     *qla1280_get_token(char *, char *);
316 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
317 STATIC inline void mdelay(int);
318 #endif
319 static inline void qla1280_enable_intrs(scsi_qla_host_t *);
320 static inline void qla1280_disable_intrs(scsi_qla_host_t *);
321
322 /*
323  *  QLogic ISP1280 Hardware Support Function Prototypes.
324  */
325 STATIC uint8_t   qla1280_initialize_adapter(struct scsi_qla_host   *ha);
326 STATIC uint8_t   qla1280_enable_tgt(scsi_qla_host_t *, uint8_t);
327 STATIC uint8_t   qla1280_isp_firmware(scsi_qla_host_t *);
328 STATIC uint8_t   qla1280_pci_config(scsi_qla_host_t *);
329 STATIC uint8_t   qla1280_chip_diag(scsi_qla_host_t *);
330 STATIC uint8_t   qla1280_setup_chip(scsi_qla_host_t *);
331 STATIC uint8_t   qla1280_init_rings(scsi_qla_host_t *);
332 STATIC uint8_t   qla1280_nvram_config(scsi_qla_host_t *);
333 STATIC uint8_t   qla1280_mailbox_command(scsi_qla_host_t *, uint8_t, uint16_t *);
334 STATIC uint8_t   qla1280_bus_reset(scsi_qla_host_t *, uint8_t);
335 STATIC uint8_t   qla1280_device_reset(scsi_qla_host_t *, uint8_t, uint32_t);
336 STATIC uint8_t   qla1280_abort_device(scsi_qla_host_t *, uint8_t, uint32_t, uint32_t);
337 STATIC uint8_t   qla1280_abort_command(scsi_qla_host_t *, srb_t *),
338 #if  QLA1280_64BIT_SUPPORT
339                  qla1280_64bit_start_scsi(scsi_qla_host_t *, srb_t *),
340 #endif
341                  qla1280_32bit_start_scsi(scsi_qla_host_t *, srb_t *),
342                  qla1280_abort_isp(scsi_qla_host_t *);
343 STATIC void      qla1280_nv_write(scsi_qla_host_t *, uint16_t),
344                  qla1280_nv_delay(scsi_qla_host_t *),
345                  qla1280_poll(scsi_qla_host_t *),
346                  qla1280_reset_adapter(scsi_qla_host_t *),
347                  qla1280_marker(scsi_qla_host_t *, uint8_t, uint32_t, uint32_t, uint8_t),
348                  qla1280_isp_cmd(scsi_qla_host_t *),
349                  qla1280_isr(scsi_qla_host_t *, srb_t **, srb_t **),
350                  qla1280_rst_aen(scsi_qla_host_t *),
351                  qla1280_status_entry(scsi_qla_host_t *, sts_entry_t *, srb_t **,
352                                       srb_t **),
353                  qla1280_error_entry(scsi_qla_host_t *, response_t *, srb_t **,
354                                      srb_t **),
355                  qla1280_restart_queues(scsi_qla_host_t *),
356                  qla1280_abort_queues(scsi_qla_host_t *);
357 STATIC uint16_t  qla1280_get_nvram_word(scsi_qla_host_t *, uint32_t),
358                  qla1280_nvram_request(scsi_qla_host_t *, uint32_t),
359                  qla1280_debounce_register(volatile uint16_t *);
360 STATIC request_t *qla1280_req_pkt(scsi_qla_host_t *);
361 int  qla1280_check_for_dead_scsi_bus(scsi_qla_host_t *ha, srb_t *sp);
362 STATIC uint8_t qla1280_mem_alloc(scsi_qla_host_t *ha);
363 STATIC uint8_t  qla1280_register_with_Linux(scsi_qla_host_t *ha, uint8_t maxchannels);
364
365 STATIC uint8_t qla12160_set_target_parameters(scsi_qla_host_t *, uint32_t, uint32_t, uint32_t, nvram160_t *);
366 STATIC void qla12160_get_target_parameters(scsi_qla_host_t *, uint32_t, uint32_t, uint32_t);
367
368 #if QL1280_TARGET_MODE_SUPPORT
369 STATIC void      qla1280_enable_lun(scsi_qla_host_t *, uint8_t, uint32_t),
370                  qla1280_notify_ack(scsi_qla_host_t *, notify_entry_t *),
371                  qla1280_immed_notify(scsi_qla_host_t *, notify_entry_t *),
372                  qla1280_accept_io(scsi_qla_host_t *, ctio_ret_entry_t *),
373 #if  QLA1280_64BIT_SUPPORT
374                  qla1280_64bit_continue_io(scsi_qla_host_t *, atio_entry_t *, uint32_t,
375                                      paddr32_t *),
376 #endif
377                  qla1280_32bit_continue_io(scsi_qla_host_t *, atio_entry_t *, uint32_t,
378                                      paddr32_t *),
379                  qla1280_atio_entry(scsi_qla_host_t *, atio_entry_t *),
380                  qla1280_notify_entry(scsi_qla_host_t *, notify_entry_t *);
381 #endif  /* QLA1280_TARGET_MODE_SUPPORT */
382
383 #ifdef QL_DEBUG_ROUTINES
384 /*
385  *  Driver Debug Function Prototypes.
386  */
387 STATIC uint8_t  qla1280_getbyte(uint8_t *);
388 STATIC uint16_t qla1280_getword(uint16_t *);
389 STATIC uint32_t qla1280_getdword(uint32_t *);
390 STATIC void     qla1280_putbyte(uint8_t *, uint8_t),
391                 qla1280_putword(uint16_t *, uint16_t),
392                 qla1280_putdword(uint32_t *, uint32_t),
393                 qla1280_print(caddr_t),
394                 qla1280_output_number(uint32_t, uint8_t),
395                 qla1280_putc(uint8_t),
396                 qla1280_dump_buffer(caddr_t, uint32_t);
397
398 char          debug_buff[80];
399 #if DEBUG_QLA1280 
400 STATIC uint8_t ql_debug_print = 1;
401 #else
402 STATIC uint8_t ql_debug_print = 0;
403 #endif
404 #endif
405
406 /*
407  * insmod needs to find the variable and make it point to something
408  */
409 #ifdef MODULE
410 static char *options = NULL;
411 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,18)
412
413 /* insmod qla1280 options=verbose" */
414 MODULE_PARM(options, "s");  
415 #endif
416 /*
417  * Just in case someone uses commas to separate items on the insmod
418  * command line, we define a dummy buffer here to avoid having insmod
419  * write wild stuff into our code segment
420  */
421 static char dummy_buffer[60] = "Please don't add commas in your insmod command!!\n";
422
423 #endif
424
425 /* We use the Scsi_Pointer structure that's included with each command
426  * SCSI_Cmnd as a scratchpad for our SRB.
427  *
428  * SCp will always point to the SRB structure (defined in qla1280.h).
429  * It is define as follows:
430  *  - SCp.ptr  -- > pointer back to the cmd
431  *  - SCp.this_residual --> used as forward pointer to next srb
432  *  - SCp.buffer --> used as backward pointer to next srb
433  *  - SCp.buffers_residual --> used as flags field
434  *  - SCp.have_data_in --> not used
435  *  - SCp.sent_command --> not used
436  *  - SCp.phase --> not used
437  */
438
439 #define CMD_SP(Cmnd)            (&(Cmnd)->SCp)
440 #define CMD_XFRLEN(Cmnd)        (Cmnd)->request_bufflen
441 #define CMD_CDBLEN(Cmnd)        (Cmnd)->cmd_len
442 #define CMD_CDBP(Cmnd)          (Cmnd)->cmnd
443 #define CMD_SNSP(Cmnd)          (Cmnd)->sense_buffer
444 #define CMD_SNSLEN(Cmnd)        (sizeof (Cmnd)->sense_buffer)
445 #define CMD_RESULT(Cmnd)        ((Cmnd)->result)
446 #define CMD_HANDLE(Cmnd)        ((Cmnd)->host_scribble)
447
448 /*****************************************/
449 /*   ISP Boards supported by this driver */
450 /*****************************************/
451 #define QLA1280_VENDOR_ID   0x1077
452 #define QLA1080_DEVICE_ID   0x1080
453 #define QLA1240_DEVICE_ID   0x1240
454 #define QLA1280_DEVICE_ID   0x1280
455 #define QLA12160_DEVICE_ID  0x1216
456 #define QLA10160_DEVICE_ID  0x1016
457 #define NUM_OF_ISP_DEVICES        6
458
459 typedef struct _qlaboards 
460 {
461    unsigned char   bdName[9];       /* Board ID String */
462    unsigned long   device_id;       /* Device PCI ID   */
463    int   numPorts;                  /* Number of SCSI ports */
464    unsigned short   *fwcode;        /* pointer to FW array         */
465    unsigned long    *fwlen;         /* number of words in array    */
466    unsigned short   *fwstart;       /* start address for F/W       */
467    unsigned char   *fwver;          /* Ptr to F/W version array    */
468 } qla_boards_t;
469
470 struct _qlaboards   QLBoardTbl[NUM_OF_ISP_DEVICES] = 
471 {
472    /* Name ,  Board PCI Device ID,         Number of ports */
473   {"QLA1080 ", QLA1080_DEVICE_ID,           1,        
474                &fw1280ei_code01[0],  (unsigned long *)&fw1280ei_length01,&fw1280ei_addr01, &fw1280ei_version_str[0] },       
475   {"QLA1240 ", QLA1240_DEVICE_ID,           2,       
476                &fw1280ei_code01[0],  (unsigned long *)&fw1280ei_length01,&fw1280ei_addr01, &fw1280ei_version_str[0] },       
477   {"QLA1280 ", QLA1280_DEVICE_ID,           2,      
478                &fw1280ei_code01[0],  (unsigned long *)&fw1280ei_length01,&fw1280ei_addr01, &fw1280ei_version_str[0] },       
479   {"QLA12160 ", QLA12160_DEVICE_ID,          2,      
480                &fw12160i_code01[0],  (unsigned long *)&fw12160i_length01,&fw12160i_addr01, &fw12160i_version_str[0] },       
481   {"QLA10160 ", QLA10160_DEVICE_ID,          1,      
482                &fw12160i_code01[0],  (unsigned long *)&fw12160i_length01,&fw12160i_addr01, &fw12160i_version_str[0] },       
483   {"        ",                 0,           0}
484 };
485
486 static unsigned long qla1280_verbose = 1L;
487 static scsi_qla_host_t *qla1280_hostlist = NULL;
488 #ifdef QLA1280_PROFILE
489 static int qla1280_buffer_size = 0;
490 static char *qla1280_buffer = NULL;
491 #endif
492
493 #ifdef QL_DEBUG_LEVEL_3 
494 #define ENTER(x)        sprintf(debug_buff,"qla1280 : Entering %s()\n\r", x); \
495                         qla1280_print(debug_buff);
496 #define LEAVE(x)        sprintf(debug_buff,"qla1280 : Leaving %s()\n\r", x); \
497                         qla1280_print(debug_buff);
498 #define ENTER_INTR(x)   sprintf(debug_buff,"qla1280 : Entering %s()\n\r", x); \
499                         qla1280_print(debug_buff);
500 #define LEAVE_INTR(x)   sprintf(debug_buff,"qla1280 : Leaving %s()\n\r", x); \
501                         qla1280_print(debug_buff);
502 #define DEBUG3(x)       x
503 #else
504 #define ENTER(x)
505 #define LEAVE(x)
506 #define ENTER_INTR(x)
507 #define LEAVE_INTR(x)
508 #define DEBUG3(x)
509 #endif
510
511 #if  DEBUG_QLA1280  
512 #define COMTRACE(x)
513 /* #define COMTRACE(x)     qla1280_putc(x); */
514 #define DEBUG(x)        x
515 #else
516 #define DEBUG(x)
517 #define COMTRACE(x)
518 #endif
519
520 #ifdef QL_DEBUG_LEVEL_2 
521 #define DEBUG2(x)       x
522 #else
523 #define DEBUG2(x)
524 #endif
525 #define DEBUG5(x)
526
527 #if (BITS_PER_LONG==64)
528 #   define OFFSET(w)   (((uint64_t) &w) & 0xFF)   /* 256 byte offsets */
529 #else
530 #   define OFFSET(w)   (((uint32_t) &w) & 0xFF)   /* 256 byte offsets */
531 #endif
532
533 #define SCSI_BUS_32(scp)   ((scp)->channel)
534 #define SCSI_TCN_32(scp)    ((scp)->target)
535 #define SCSI_LUN_32(scp)    ((scp)->lun)
536
537 /****************************************************************************/
538 /*  LINUX -  Loadable Module Functions.                                     */
539 /****************************************************************************/
540
541
542 /*************************************************************************
543  *   qla1280_set_info
544  *
545  * Description:
546  *   Set parameters for the driver from the /proc filesystem.
547  *
548  * Returns:
549  *************************************************************************/
550 int
551 qla1280_set_info(char *buffer, int length, struct Scsi_Host *HBAptr)
552 {
553   return (-ENOSYS);  /* Currently this is a no-op */
554 }
555
556 /*************************************************************************
557  * qla1280_proc_info
558  *
559  * Description:
560  *   Return information to handle /proc support for the driver.
561  *
562  * buffer - ptrs to a page buffer
563  *
564  * Returns:
565  *************************************************************************/
566 #ifdef QLA1280_PROFILE
567 #define PROC_BUF        (&qla1280_buffer[size])
568 #define LUN_ID       (targ_lun>>(MAX_T_BITS+MAX_L_BITS)),((targ_lun>>MAX_L_BITS)&0xf), targ_lun&0x7 
569 #endif
570 int
571 qla1280_proc_info ( char *buffer, char **start, off_t offset, int length, 
572                     int hostno, int inout)
573 {
574 #ifdef QLA1280_PROFILE
575   struct Scsi_Host *host;
576   scsi_qla_host_t *ha;
577   int    size = 0;
578   int  targ_lun;
579   scsi_lu_t  *up;
580   int   no_devices;
581
582   printk("Entering proc_info 0x%p,0x%lx,0x%x,0x%x\n",buffer,offset,length,hostno);
583   host = NULL;
584   /* find the host they want to look at */
585   for(ha=qla1280_hostlist; (ha != NULL) && ha->host->host_no != hostno; ha=ha->next)
586     ;
587
588   if (!ha)
589   {
590     size += sprintf(buffer, "Can't find adapter for host number %d\n", hostno);
591     if (size > length)
592     {
593       return (size);
594     }
595     else
596     {
597       return (length);
598     }
599   }
600
601   host = ha->host;
602   if (inout == TRUE) /* Has data been written to the file? */ 
603   {
604     return (qla1280_set_info(buffer, length, host));
605   }
606
607   /* compute number of active devices */
608   no_devices = 0;
609   for (targ_lun = 0; targ_lun < MAX_EQ; targ_lun++)
610   {
611           if( (up = ha->dev[targ_lun]) == NULL )
612               continue;
613           no_devices++;
614   }
615   /* size = 112 * no_devices; */
616   size = 4096;
617   /* round up to the next page */
618   
619   /* 
620    * if our old buffer is the right size use it otherwise 
621    * allocate a new one.
622    */
623   if (qla1280_buffer_size != size)
624   {
625     /* deallocate this buffer and get a new one */
626     if (qla1280_buffer != NULL) 
627     {
628       kfree(qla1280_buffer);
629       qla1280_buffer_size = 0;
630     }
631     qla1280_buffer = kmalloc(size, GFP_KERNEL);
632   }
633   if (qla1280_buffer == NULL)
634   {
635     size = sprintf(buffer, "qla1280 - kmalloc error at line %d\n",
636         __LINE__);
637     return size;
638   }
639   qla1280_buffer_size = size;
640
641   size = 0;
642   size += sprintf(PROC_BUF, "Qlogic 1280/1080 SCSI driver version: ");   /* 43 bytes */
643   size += sprintf(PROC_BUF, "%5s, ", QLA1280_VERSION);                         /* 5        */
644   size += sprintf(PROC_BUF, "Qlogic Firmware version: ");                     /* 25       */
645   size += sprintf(PROC_BUF, "%2d.%2d.%2d",_firmware_version[0],           /* 8        */
646                                           ql12_firmware_version[1],
647                                           ql12_firmware_version[2]);
648   size += sprintf(PROC_BUF, "\n");                                             /* 1       */
649                            
650   size += sprintf(PROC_BUF, "SCSI Host Adapter Information: %s\n", QLBoardTbl[ha->devnum].bdName);
651   size += sprintf(PROC_BUF, "Request Queue = 0x%lx, Response Queue = 0x%lx\n",
652                         ha->request_dma,
653                         ha->response_dma);
654   size += sprintf(PROC_BUF, "Request Queue count= 0x%x, Response Queue count= 0x%x\n",
655                         REQUEST_ENTRY_CNT,
656                         RESPONSE_ENTRY_CNT);
657   size += sprintf(PROC_BUF,"Number of pending commands = 0x%lx\n", ha->actthreads);
658   size += sprintf(PROC_BUF,"Number of queued commands = 0x%lx\n", ha->qthreads);
659   size += sprintf(PROC_BUF,"Number of free request entries = %d\n",ha->req_q_cnt);
660   size += sprintf(PROC_BUF, "\n");                                             /* 1       */
661                         
662   size += sprintf(PROC_BUF, "Attached devices:\n");
663   /* scan for all equipment stats */ 
664   for (targ_lun = 0; targ_lun < MAX_EQ; targ_lun++)
665   {
666       if( (up = ha->dev[targ_lun]) == NULL )
667            continue;
668       if( up->io_cnt == 0 )
669       {
670           size += sprintf(PROC_BUF,"(%2d:%2d:%2d) No stats\n",LUN_ID);
671            continue;
672       }
673       /* total reads since boot */
674       /* total writes since boot */
675       /* total requests since boot  */
676       size += sprintf(PROC_BUF, "Total requests %ld,",up->io_cnt);
677       /* current number of pending requests */
678       size += sprintf(PROC_BUF, "(%2d:%2d:%2d) pending requests %d,",LUN_ID,up->q_outcnt);
679       /* avg response time */
680       size += sprintf(PROC_BUF, "Avg response time %ld%%,",(up->resp_time/up->io_cnt)*100);
681       
682       /* avg active time */
683       size += sprintf(PROC_BUF, "Avg active time %ld%%\n",(up->act_time/up->io_cnt)*100);
684   }
685
686   if (size >= qla1280_buffer_size)
687   {
688     printk(KERN_WARNING "qla1280: Overflow buffer in qla1280_proc.c\n");
689   }
690
691   if (offset > size - 1)
692   {
693     kfree(qla1280_buffer);
694     qla1280_buffer = NULL;
695     qla1280_buffer_size = length = 0;
696     *start = NULL;
697   }
698   else
699   {
700     *start = &qla1280_buffer[offset];   /* Start of wanted data */
701     if (size - offset < length)
702     {
703       length = size - offset;
704     }
705   }
706 #endif
707
708   return (length);
709 }
710
711
712 /**************************************************************************
713  * qla1280_detect
714  *    This routine will probe for Qlogic 1280 SCSI host adapters.
715  *    It returns the number of host adapters of a particular
716  *    type that were found.      It also initialize all data necessary for 
717  *    the driver.  It is passed-in the host number, so that it
718  *    knows where its first entry is in the scsi_hosts[] array.
719  *
720  * Input:
721  *     template - pointer to SCSI template
722  *
723  * Returns:
724  *  num - number of host adapters found.  
725  **************************************************************************/
726 int
727 qla1280_detect(Scsi_Host_Template *template)
728 {
729     int num_hosts = 0;
730     struct Scsi_Host *host;
731     scsi_qla_host_t *ha, *cur_ha;
732     struct _qlaboards  *bdp;
733     int i, j;
734 #if LINUX_VERSION_CODE <= KERNEL_VERSION(2,1,95)
735     unsigned int piobase;
736     unsigned char pci_bus, pci_devfn, pci_irq;
737     config_reg_t   *cfgp = 0;
738 #endif
739     device_reg_t   *reg;
740     char   *cp;
741 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
742     struct pci_dev *pdev = NULL;
743 #else
744     int index;
745 #endif
746
747     ENTER("qla1280_detect");
748
749 #ifdef CHECKSRBSIZE
750     if (sizeof(srb_t) > sizeof(Scsi_Pointer) )
751     {
752       printk("Redefine SRB - its too big");
753       return 0;
754     }
755 #endif
756
757 #ifdef MODULE
758         DEBUG(sprintf(debug_buff,"DEBUG: qla1280_detect starts at address = %p\n",qla1280_detect);)
759         DEBUG(qla1280_print(debug_buff);)
760     /*
761     * If we are called as a module, the qla1280 pointer may not be null
762     * and it would point to our bootup string, just like on the lilo
763     * command line.  IF not NULL, then process this config string with
764     * qla1280_setup
765     *
766     * Boot time Options
767     * To add options at boot time add a line to your lilo.conf file like:
768     * append="qla1280=verbose,max_tags:{{255,255,255,255},{255,255,255,255}}"
769     * which will result in the first four devices on the first two
770     * controllers being set to a tagged queue depth of 32.
771     */
772     if(options)
773         qla1280_setup(options, NULL);
774     if(dummy_buffer[0] != 'P')
775         printk(KERN_WARNING "qla1280: Please read the file /usr/src/linux/drivers"
776                 "/scsi/README.qla1280\n"
777                 "qla1280: to see the proper way to specify options to the qla1280 "
778                 "module\n"
779                 "qla1280: Specifically, don't use any commas when passing arguments to\n"
780                 "qla1280: insmod or else it might trash certain memory areas.\n");
781 #endif
782
783     if ((int) !pcibios_present())
784     {
785                 printk("scsi: PCI not present\n");
786                 return 0;
787     } /* end of IF */
788     bdp = &QLBoardTbl[0];
789     qla1280_hostlist = NULL;
790 #if 0
791     template->proc_dir = &proc_scsi_qla1280;
792 #else
793     template->proc_name = "qla1280";
794 #endif
795     
796         /* Try and find each different type of adapter we support */
797         for( i=0; bdp->device_id != 0 && i < NUM_OF_ISP_DEVICES; i++, bdp++ ) {
798 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
799                 while ((pdev = pci_find_device(QLA1280_VENDOR_ID,
800                         bdp->device_id, pdev ) ))  {
801                 if (pci_enable_device(pdev)) continue;
802 #else
803                 while (!(pcibios_find_device(QLA1280_VENDOR_ID,
804                         bdp->device_id,
805                         index++, &pci_bus, &pci_devfn)) )  {
806 #endif
807                 /* found a adapter */
808                 host = scsi_register(template, sizeof(scsi_qla_host_t));
809                 if (!host) { 
810                         printk(KERN_WARNING "qla1280: Failed to register host, aborting.\n");
811                         return 0;
812                 }
813                 scsi_set_pci_device(host, pdev);
814                 ha = (scsi_qla_host_t *) host->hostdata;
815                 /* Clear our data area */
816                 for( j =0, cp = (char *)ha;  j < sizeof(scsi_qla_host_t); j++)
817                         *cp = 0;
818                 /* Sanitize the information from PCI BIOS.  */
819 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
820                 host->irq = pdev->irq;
821                 host->io_port = pci_resource_start(pdev, 0);
822                 ha->pci_bus = pdev->bus->number;
823                 ha->pci_device_fn = pdev->devfn;
824                 ha->pdev = pdev;
825 #else
826                 pcibios_read_config_byte(pci_bus, pci_devfn, OFFSET(cfgp->interrupt_line), &pci_irq);
827                 pcibios_read_config_dword(pci_bus, pci_devfn, OFFSET(cfgp->base_port), &piobase);
828                 host->irq = pci_irq;
829                 host->io_port = (unsigned int) piobase;
830                 host->io_port &= PCI_BASE_ADDRESS_IO_MASK;
831                 ha->pci_bus = pci_bus;
832                 ha->pci_device_fn = pci_devfn;
833 #endif
834                 ha->device_id = bdp->device_id;
835     
836                 ha->devnum = i;
837                 if( qla1280_mem_alloc(ha) ) {
838                         printk(KERN_INFO "qla1280: Failed to allocate memory for adapter\n");
839                 }
840                 
841                 ha->ports = bdp->numPorts; 
842                 ha->iobase = (device_reg_t *) host->io_port;
843                 ha->host = host;
844                 ha->host_no = host->host_no;
845
846                 /* load the F/W, read paramaters, and init the H/W */
847                 if (qla1280_initialize_adapter(ha))
848                 {
849
850                     printk(KERN_INFO "qla1280: Failed to initialized adapter\n");
851                     qla1280_mem_free(ha);
852                     scsi_unregister(host);
853                     continue;
854                 }
855                 
856                 host->max_channel = bdp->numPorts-1; 
857                 ha->instance = num_hosts;
858                 /* Register our resources with Linux */
859                 if( qla1280_register_with_Linux(ha, bdp->numPorts-1) ) {
860                         printk(KERN_INFO "qla1280: Failed to register our resources\n");
861                         qla1280_mem_free(ha);
862                         scsi_unregister(host);
863                         continue;
864                 }
865
866
867                 reg = ha->iobase;
868                 /* Disable ISP interrupts. */
869                 qla1280_disable_intrs(ha);
870
871                 /* Insure mailbox registers are free. */
872                 WRT_REG_WORD(&reg->semaphore, 0);
873                 WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
874                 WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
875
876                 /* Enable chip interrupts. */
877                 qla1280_enable_intrs(ha);
878                
879                 /* Insert new entry into the list of adapters */
880                 ha->next = NULL;
881                 if( qla1280_hostlist == NULL )
882                 {
883                     cur_ha = qla1280_hostlist = ha;
884                 }
885                 else
886                 {
887                     cur_ha = qla1280_hostlist;
888                     while( cur_ha->next != NULL )
889                         cur_ha = cur_ha->next;
890                     cur_ha->next = ha;
891                 }
892                 num_hosts++;
893             }  /* end of WHILE */
894         } /* end of FOR */
895
896     LEAVE("qla1280_detect");
897     return num_hosts; 
898 }
899
900 /**************************************************************************
901 *   qla1280_register_with_Linux
902 *
903 * Description:
904 *   Free the passed in Scsi_Host memory structures prior to unloading the
905 *   module.
906 *
907 * Input:
908 *     ha - pointer to host adapter structure
909 *     maxchannels - MAX number of channels.
910 *
911 * Returns:
912 *  0 - Sucessfully reserved resources.
913 *  1 - Failed to reserved a resource.
914 **************************************************************************/
915 STATIC uint8_t  qla1280_register_with_Linux(scsi_qla_host_t *ha, uint8_t maxchannels)
916 {
917
918         struct Scsi_Host *host = ha->host;
919
920         host->can_queue = 0xfffff;  /* unlimited  */
921         host->cmd_per_lun = 1;
922        host->select_queue_depths = qla1280_select_queue_depth;
923         host->n_io_port = 0xFF;
924         host->base = (unsigned long) ha->mmpbase;
925         host->max_channel = maxchannels; 
926        host->max_lun = MAX_LUNS-1; 
927         host->unique_id = ha->instance;
928        host->max_id = MAX_TARGETS; 
929        host->unique_id = ha->instance;
930
931         /* set our host ID  (need to do something about our two IDs) */
932        host->this_id = ha->bus_settings[0].id;
933        /* Register the IRQ with Linux (sharable) */
934        if ( request_irq(host->irq, qla1280_intr_handler, SA_INTERRUPT| SA_SHIRQ, "qla1280", ha))
935        {
936           printk("qla1280 : Failed to reserved interrupt %d already in use\n", host->irq);
937           qla1280_mem_free(ha);
938           scsi_unregister(host);
939              return 1;
940        }
941
942        /* Register the I/O space with Linux */
943        if (check_region(host->io_port, 0xff))
944        {
945            printk("qla1280 : Failed to reserved i/o region 0x%04lx-0x%04lx already in use\n",
946               host->io_port, host->io_port + 0xff);
947            free_irq(host->irq, NULL);
948            qla1280_mem_free(ha);
949            scsi_unregister(host);
950              return 1;
951        }
952
953        request_region(host->io_port, 0xff, "qla1280");
954
955         return 0;
956 }
957
958
959 /**************************************************************************
960  *   qla1280_release
961  *   Free the passed in Scsi_Host memory structures prior to unloading the
962  *   module.
963  **************************************************************************/
964 int
965 qla1280_release(struct Scsi_Host *host)
966 {
967     scsi_qla_host_t *ha = (scsi_qla_host_t *) host->hostdata;
968
969     ENTER("qla1280_release");
970
971     if( !ha->flags.online )
972         return(0);
973
974     /* turn-off interrupts on the card */
975     WRT_REG_WORD(&ha->iobase->ictrl, 0);
976
977     /* Detach interrupts */
978     if(host->irq)
979         free_irq(host->irq, ha);
980
981     /* release io space registers  */
982     if( host->io_port )
983         release_region(host->io_port, 0xff);
984
985 #if MEMORY_MAPPED_IO
986     if(ha->mmpbase)
987     {
988 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
989         vfree((void *) (((unsigned long) ha->mmpbase) & PAGE_MASK));
990 #else
991         iounmap((void *) (((unsigned long) ha->mmpbase) & PAGE_MASK));
992 #endif
993     }
994 #endif /* MEMORY_MAPPED_IO */
995     qla1280_mem_free(ha);
996
997     ENTER("qla1280_release");
998     return(0);
999 }
1000
1001 /**************************************************************************
1002  *   qla1280_info
1003  *     Return a string describing the driver.
1004  **************************************************************************/
1005 const char *
1006 qla1280_info(struct Scsi_Host *host)
1007 {
1008     static char qla1280_buffer[125];
1009     char *bp;
1010     scsi_qla_host_t *ha;
1011     qla_boards_t   *bdp; 
1012
1013     bp = &qla1280_buffer[0];
1014     ha = (scsi_qla_host_t *)host->hostdata;
1015     bdp = &QLBoardTbl[ha->devnum];
1016     memset(bp, 0, sizeof(qla1280_buffer));
1017     sprintf(bp,
1018             "QLogic %sPCI to SCSI Host Adapter: bus %d device %d irq %d\n"
1019             "       Firmware version: %2d.%02d.%02d, Driver version %s",
1020             (char *)&bdp->bdName[0], ha->pci_bus, (ha->pci_device_fn & 0xf8) >> 3, host->irq,
1021             bdp->fwver[0],bdp->fwver[1],bdp->fwver[2],
1022             QLA1280_VERSION);
1023     return(bp);
1024 }
1025
1026 /**************************************************************************
1027  *   qla1200_queuecommand
1028  *     Queue a command to the controller.
1029  *
1030  * Note:
1031  * The mid-level driver tries to ensures that queuecommand never gets invoked
1032  * concurrently with itself or the interrupt handler (although the
1033  * interrupt handler may call this routine as part of request-completion
1034  * handling).   Unfortunely, it sometimes calls the scheduler in interrupt
1035  * context which is a big NO! NO!.
1036  **************************************************************************/
1037 int
1038 qla1280_queuecommand(Scsi_Cmnd *cmd, void (*fn)(Scsi_Cmnd *))
1039 {
1040     scsi_qla_host_t *ha;
1041     srb_t  *sp;
1042 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1043     unsigned long cpu_flags = 0;
1044 #endif
1045     struct Scsi_Host *host;
1046     uint32_t        b, t, l;
1047     scsi_lu_t       *q;
1048     u_long          handle;
1049
1050     ENTER("qla1280_queuecommand");
1051     COMTRACE('C') 
1052
1053     host = cmd->host;
1054     ha = (scsi_qla_host_t *) host->hostdata;
1055
1056     /* send command to adapter */
1057     sp = (srb_t *) CMD_SP(cmd);
1058     sp->cmd =  cmd;
1059     cmd->scsi_done = fn;
1060     if (cmd->flags == 0)  /* new command */
1061     {
1062         sp->flags = 0;
1063     }
1064
1065     DEBUG5(qla1280_print_scsi_cmd(cmd));
1066
1067     /* Generate LU queue on bus, target, LUN */
1068     b = SCSI_BUS_32(cmd);
1069     t = SCSI_TCN_32(cmd);
1070     l = SCSI_LUN_32(cmd);
1071     if((q = LU_Q(ha, b, t, l)) == NULL )
1072     {
1073         DRIVER_LOCK
1074         if( (q = (scsi_lu_t *)KMALLOC(sizeof(struct scsi_lu))) )
1075         {
1076            LU_Q(ha, b, t, l) = q;
1077            BZERO(q,sizeof(struct scsi_lu));
1078            DEBUG(sprintf(debug_buff,"Allocate new device queue 0x%x\n",q));
1079            DEBUG(qla1280_print(debug_buff));
1080            DRIVER_UNLOCK
1081         }
1082         else
1083         {
1084             CMD_RESULT(cmd) = (int) (DID_BUS_BUSY << 16);
1085             qla1280_done_q_put(sp, &ha->done_q_first, &ha->done_q_last);
1086
1087             schedule_task(&ha->run_qla_bh);
1088             ha->flags.dpc_sched = TRUE;
1089             DRIVER_UNLOCK
1090             return(0);
1091         }
1092     }
1093     /* Set an invalid handle until we issue the command to ISP */
1094     /* then we will set the real handle value.                 */
1095     handle = INVALID_HANDLE;  
1096     CMD_HANDLE(cmd) = (unsigned char *)handle;
1097
1098     /* Bookkeeping information */
1099     sp->r_start = jiffies;       /* time the request was received */
1100     sp->u_start = 0;              
1101
1102     /* add the command to our queue */
1103     ha->qthreads++;
1104     qla1280_putq_t(q,sp);
1105     
1106     DEBUG(sprintf(debug_buff,"qla1280_queuecmd: queue pid=%d, hndl=0x%x\n\r",cmd->pid,handle));
1107     DEBUG(qla1280_print(debug_buff));
1108
1109     /* send command to adapter */
1110     DRIVER_LOCK
1111         if (q->q_outcnt == 0)
1112             qla1280_restart_queues(ha);
1113     DRIVER_UNLOCK
1114     
1115     
1116     LEAVE("qla1280_queuecommand");
1117     return (0);
1118 }
1119
1120 /**************************************************************************
1121  *   qla1200_abort
1122  *     Abort the speciifed SCSI command(s).
1123  **************************************************************************/
1124 int
1125 qla1280_abort(Scsi_Cmnd *cmd)
1126 {
1127     scsi_qla_host_t *ha;
1128     srb_t  *sp;
1129 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1130     unsigned long cpu_flags = 0;
1131 #endif
1132     struct Scsi_Host *host;
1133     uint32_t        b, t, l;
1134     scsi_lu_t       *q;
1135     int return_status = SCSI_ABORT_SUCCESS;
1136     int found = 0;
1137     int i;
1138     u_long     handle;
1139     u_short    data;
1140
1141     ENTER("qla1280_abort");
1142     COMTRACE('A')
1143     ha = (scsi_qla_host_t *) cmd->host->hostdata;
1144     host = cmd->host;
1145     DRIVER_LOCK
1146
1147     /* Get the SCSI request ptr */
1148     sp = (srb_t *) CMD_SP(cmd);
1149     handle = (u_long) CMD_HANDLE(cmd);
1150     if (qla1280_verbose)
1151         printk("scsi(%d): ABORT Command=0x%lx, handle=0x%lx\n",(int)ha->host_no,(long)cmd,handle);
1152
1153     /* Check for pending interrupts. */
1154     if( handle == 0L )
1155     {
1156     COMTRACE('a')
1157         /* we never got this command */
1158         printk(KERN_INFO "qla1280: Aborting a NULL handle\n");
1159         DRIVER_UNLOCK
1160                 return(SCSI_ABORT_NOT_RUNNING);  /* no action - we don't have command */
1161     }
1162     data = qla1280_debounce_register(&ha->iobase->istatus);
1163     if( !(ha->flags.in_isr) && (data & RISC_INT) )
1164     {
1165         /* put any pending command in done queue */
1166         qla1280_isr(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1167     }
1168
1169     handle = (u_long) CMD_HANDLE(cmd);
1170
1171     /* Generate LU queue on bus, target, LUN */
1172     b = SCSI_BUS_32(cmd);
1173     t = SCSI_TCN_32(cmd);
1174     l = SCSI_LUN_32(cmd);
1175     if((q = LU_Q(ha, b, t, l)) == NULL )
1176     {
1177     COMTRACE('a')
1178         /* No lun queue -- command must not be active */
1179         DRIVER_UNLOCK
1180         printk(KERN_WARNING "qla1280 (%d:%d:%d): No LUN queue for the specified device\n",(int)b,(int)t,(int)l);
1181         return(SCSI_ABORT_NOT_RUNNING);  /* no action - we don't have command */
1182     }
1183
1184 #if AUTO_ESCALATE_ABORT
1185     if ( (sp->flags & SRB_ABORTED) )
1186     {
1187         DRIVER_UNLOCK
1188         DEBUG(qla1280_print("qla1280_abort: Abort escalayted - returning SCSI_ABORT_SNOOZE.\n\r"));
1189         return(SCSI_ABORT_SNOOZE);
1190     }
1191 #endif
1192
1193     if ( (sp->flags & SRB_ABORT_PENDING) )
1194     {
1195     COMTRACE('a')
1196         DRIVER_UNLOCK
1197         if( qla1280_verbose  )
1198             printk("scsi(): Command has a pending abort message - ABORT_PENDING.\n");
1199         DEBUG(qla1280_print("qla1280: Command has a pending abort message - ABORT_PENDING.\n\r"));
1200         return(SCSI_ABORT_PENDING);
1201     }
1202
1203 #if  STOP_ON_ABORT 
1204     printk("Scsi layer issued a ABORT command= 0x%x\n",(int)cmd);
1205     DEBUG2(qla1280_print_scsi_cmd(cmd));
1206 #endif
1207
1208     ha->flags.in_abort = TRUE;
1209     /*
1210     * Normally, would would need to search our queue for the specified command
1211     * but; since our sp contains the cmd ptr, we can just remove it from our
1212     * LUN queue.
1213     */
1214     if( !(sp->flags&SRB_SENT) )
1215     { 
1216         found++;
1217         if( qla1280_verbose  )
1218             printk("scsi(): Command returned from queue aborted.\n");
1219         DEBUG(qla1280_print("qla1280: Command returned from queue aborted.\n\r"));
1220         /* Remove srb from SCSI LU queue. */
1221         qla1280_removeq(q, sp);
1222         sp->flags |=  SRB_ABORTED;
1223         CMD_RESULT(cmd) = DID_ABORT << 16; 
1224         qla1280_done_q_put(sp, &ha->done_q_first, &ha->done_q_last);
1225         return_status = SCSI_ABORT_SUCCESS;
1226     }
1227     else
1228     {  /* find the command in our active list */
1229         for (i = 1; i < MAX_OUTSTANDING_COMMANDS; i++)
1230         {
1231             if( sp == ha->outstanding_cmds[i] )
1232             {
1233                 found++;
1234                 DEBUG(qla1280_print("qla1280: RISC aborting command.\n\r"));
1235                 qla1280_abort_command(ha,sp);
1236                 return_status = SCSI_ABORT_PENDING;
1237                 break;
1238             }
1239         }
1240     }
1241
1242 #if  STOP_ON_ABORT 
1243     qla1280_panic("qla1280_abort",ha->host);
1244 #endif
1245     if ( found == 0 )
1246         return_status = SCSI_ABORT_NOT_RUNNING;  /* no action - we don't have command */
1247
1248     DEBUG(sprintf(debug_buff, "qla1280_abort: Aborted status returned = 0x%x.\n\r",return_status));
1249     DEBUG(qla1280_print(debug_buff));
1250
1251     if( ha->done_q_first )
1252        qla1280_done(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1253     if ( found )
1254     {
1255         qla1280_restart_queues(ha);
1256     }
1257     ha->flags.in_abort = FALSE;
1258     DRIVER_UNLOCK
1259
1260     LEAVE("qla1280_abort");
1261     COMTRACE('a')
1262     return(return_status);
1263 }
1264
1265 /**************************************************************************
1266  * qla1200_reset
1267  *    The reset function will reset the SCSI bus and abort any executing
1268  *    commands. 
1269  *
1270  * Input:
1271  *      cmd = Linux SCSI command packet of the command that cause the
1272  *            bus reset.
1273  *      flags = SCSI bus reset option flags (see scsi.h)
1274  *
1275  * Returns:
1276  *      DID_RESET in cmd.host_byte of aborted command(s) 
1277  *
1278  * Note:
1279  *      Resetting the bus always succeeds - is has to, otherwise the
1280  *      kernel will panic! Try a surgical technique - sending a BUS
1281  *      DEVICE RESET message - on the offending target before pulling
1282  *      the SCSI bus reset line.
1283  **************************************************************************/
1284 int
1285 qla1280_reset(Scsi_Cmnd *cmd, unsigned int flags)
1286 {
1287     scsi_qla_host_t *ha;
1288 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1289     unsigned long cpu_flags = 0;
1290 #endif
1291     uint32_t        b, t, l;
1292     srb_t  *sp;
1293     typedef enum
1294     {
1295         ABORT_DEVICE = 1, 
1296                 DEVICE_RESET = 2, 
1297                 BUS_RESET    = 3, 
1298                 ADAPTER_RESET= 4,
1299                 RESET_DELAYED= 5,
1300                 FAIL         = 6
1301     } action_t;
1302     action_t     action = ADAPTER_RESET;
1303     u_short    data;
1304     scsi_lu_t       *q;
1305     int result;
1306
1307
1308     ENTER("qla1280_reset");
1309     COMTRACE('R')
1310     if (qla1280_verbose)
1311         printk("scsi(): Resetting Cmnd=0x%lx, Handle=0x%lx, flags=0x%x\n",(long)cmd,(long)CMD_HANDLE(cmd),flags);
1312     if ( cmd == NULL )
1313     {
1314         printk(KERN_WARNING "(scsi?:?:?:?) Reset called with NULL Scsi_Cmnd "
1315                 "pointer, failing.\n");
1316         return(SCSI_RESET_SNOOZE);
1317     }
1318     ha = (scsi_qla_host_t *) cmd->host->hostdata;
1319     sp = (srb_t *) CMD_SP(cmd);
1320
1321 #if  STOP_ON_RESET 
1322     qla1280_panic("qla1280_reset",ha->host);
1323 #endif 
1324
1325     DRIVER_LOCK
1326     /* Check for pending interrupts. */
1327     data = qla1280_debounce_register(&ha->iobase->istatus);
1328     if( !(ha->flags.in_isr) && (data & RISC_INT) )
1329     {
1330         qla1280_isr(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1331     }
1332     DRIVER_UNLOCK
1333
1334     /*
1335     * Determine the suggested action that the mid-level driver wants
1336     * us to perform.
1337     */
1338     if( CMD_HANDLE(cmd) == (unsigned char *) 0  )
1339     {
1340         /* 
1341         * if mid-level driver called reset with a orphan SCSI_Cmnd 
1342         * (i.e. a command that's not pending ), so perform the 
1343         * function specified.
1344         */
1345         if( (flags & SCSI_RESET_SUGGEST_HOST_RESET) )
1346             action = ADAPTER_RESET;
1347         else 
1348             action = BUS_RESET;
1349     }
1350     else
1351     { /* 
1352         * Mid-level driver has called reset with this SCSI_Cmnd and 
1353         * its pending.
1354         */
1355         if( flags & SCSI_RESET_SUGGEST_HOST_RESET )
1356             action = ADAPTER_RESET;
1357         else if( flags & SCSI_RESET_SUGGEST_BUS_RESET )
1358             action = BUS_RESET;
1359         else 
1360             action = DEVICE_RESET;
1361     }
1362
1363     b = SCSI_BUS_32(cmd);
1364     t = SCSI_TCN_32(cmd);
1365     l = SCSI_LUN_32(cmd);
1366     q = LU_Q(ha, b, t, l);
1367
1368 #if AUTO_ESCALATE_RESET
1369     if ( (action & DEVICE_RESET) && (q->q_flag & QLA1280_QRESET) )
1370     {
1371         printk(KERN_INFO "qla1280(%d): Bus device reset already sent to " "device, escalating.\n", (int)ha->host_no);
1372         action = BUS_RESET;
1373     }
1374     if ( (action & DEVICE_RESET) && (sp->flags & SRB_ABORT_PENDING) )
1375     {
1376         printk(KERN_INFO "qla1280(%d):Have already attempted to reach " "device with abort device\n", (int)ha->host_no);
1377         printk(KERN_INFO "qla1280(%d):message, will escalate to BUS " "RESET.\n",(int) ha->host_no);
1378         action = BUS_RESET;
1379     }
1380 #endif
1381
1382     /*
1383     *  By this point, we want to already know what we are going to do,
1384     *  so we only need to perform the course of action.
1385     */
1386     DRIVER_LOCK
1387     result = SCSI_RESET_ERROR;
1388     switch (action)
1389     {
1390         case FAIL:
1391             break;
1392
1393         case RESET_DELAYED:
1394             result = SCSI_RESET_PENDING;
1395             break;
1396
1397         case ABORT_DEVICE:
1398             ha->flags.in_reset = TRUE;
1399             if (qla1280_verbose)
1400                 printk(KERN_INFO "scsi(%d:%d:%d:%d): Queueing abort device command.\n", (int)ha->host_no,(int)b,(int)t,(int)l); 
1401             qla1280_abort_queue_single(ha,b,t,l,DID_ABORT);
1402             if( qla1280_abort_device(ha, b, t, l) == 0)
1403                 result = SCSI_RESET_PENDING;
1404             break;
1405
1406         case DEVICE_RESET:
1407             if (qla1280_verbose)
1408                 printk(KERN_INFO "scsi(%d:%d:%d:%d): Queueing device reset command.\n",(int) ha->host_no,(int)b,(int)t,(int)l); 
1409             ha->flags.in_reset = TRUE;
1410             for (l = 0; l < MAX_LUNS; l++)
1411                 qla1280_abort_queue_single(ha,b,t,l,DID_ABORT);
1412             if( qla1280_device_reset(ha, b, t) == 0 ) 
1413                 result = SCSI_RESET_PENDING;
1414             q->q_flag |= QLA1280_QRESET;
1415             break;
1416
1417         case BUS_RESET:
1418                 if (qla1280_verbose)
1419                     printk(KERN_INFO "qla1280(%d:%d:%d:%d): Issuing BUS DEVICE RESET.\n",(int) ha->host_no,(int)b,(int)t,(int)l); 
1420             ha->flags.in_reset = TRUE;
1421             for (t = 0; t < MAX_TARGETS; t++)
1422                 for (l = 0; l < MAX_LUNS; l++)
1423                     qla1280_abort_queue_single(ha,b,t,l,DID_RESET);
1424                 qla1280_bus_reset(ha, b);
1425                 /*
1426                 * The bus reset routine returns all the outstanding commands back
1427                 * with "DID_RESET" in the status field after a short delay
1428                 * by the firmware. If the mid-level time out the SCSI reset before
1429                 * our delay we may need to ignore it.
1430                 */
1431                 /* result = SCSI_RESET_PENDING | SCSI_RESET_BUS_RESET; */
1432                 result = SCSI_RESET_SUCCESS | SCSI_RESET_BUS_RESET;
1433                 mdelay(4 * 1000); barrier();
1434                 if( flags & SCSI_RESET_SYNCHRONOUS )
1435                 {
1436                   CMD_RESULT(cmd) = (int) (DID_BUS_BUSY << 16);
1437                   (*(cmd)->scsi_done)(cmd); 
1438                 }
1439                 /* ha->reset_start = jiffies; */
1440                 break;
1441
1442             case ADAPTER_RESET:
1443             default:
1444                 if (qla1280_verbose)
1445                 {
1446                     printk(KERN_INFO "scsi(%d:%d:%d:%d): Issued an ADAPTER RESET.\n",(int) ha->host_no,(int)b,(int)t,(int)l); 
1447                     printk(KERN_INFO "scsi(%d:%d:%d:%d): I/O processing will continue automatically.\n",(int) ha->host_no,(int)b,(int)t,(int)l); 
1448                 }
1449                 ha->flags.reset_active = TRUE;
1450                 /* 
1451                 * We restarted all of the commands automatically, so the mid-level code can expect 
1452                 * completions momentitarily.
1453                 */
1454                 if( qla1280_abort_isp(ha) == 0 )
1455                     result = SCSI_RESET_SUCCESS | SCSI_RESET_HOST_RESET;
1456
1457                         ha->flags.reset_active = FALSE;
1458     }
1459
1460     if( ha->done_q_first ) 
1461         qla1280_done(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1462     qla1280_restart_queues(ha);
1463     ha->flags.in_reset = FALSE;
1464     
1465 DRIVER_UNLOCK
1466     DEBUG(printk("RESET returning %d\n", result)); 
1467
1468     COMTRACE('r')
1469     LEAVE("qla1280_reset");
1470     return( result );
1471 }
1472
1473 /**************************************************************************
1474  * qla1200_biosparam
1475  *   Return the disk geometry for the given SCSI device.
1476  **************************************************************************/
1477 int
1478 qla1280_biosparam(Disk *disk, kdev_t dev, int geom[])
1479 {
1480     int heads, sectors, cylinders;
1481
1482             heads = 64;
1483     sectors = 32;
1484     cylinders = disk->capacity / (heads * sectors);
1485     if (cylinders > 1024)
1486     {
1487         heads = 255;
1488         sectors = 63;
1489         cylinders = disk->capacity / (heads * sectors);
1490         /* if (cylinders > 1023)
1491         cylinders = 1023; */
1492     }
1493
1494     geom[0] = heads;
1495     geom[1] = sectors;
1496     geom[2] = cylinders;
1497
1498     return (0);
1499 }
1500 /**************************************************************************
1501  * qla1280_intr_handler
1502  *   Handles the H/W interrupt
1503  **************************************************************************/
1504 void qla1280_intr_handler(int irq, void *dev_id, struct pt_regs *regs)
1505 {
1506 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,95)
1507     unsigned long cpu_flags = 0;
1508 #endif
1509     scsi_qla_host_t *ha;
1510     u_short    data;
1511     device_reg_t *reg;
1512
1513     ENTER_INTR("qla1280_intr_handler");
1514     COMTRACE('I')
1515     ha = (scsi_qla_host_t *) dev_id;
1516     if(!ha)
1517     {
1518         printk(KERN_INFO "scsi(): Interrupt with NULL host ptr\n");
1519         COMTRACE('X')
1520         return;
1521     }
1522 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,95)
1523     spin_lock_irqsave(ha->host->host_lock, cpu_flags);
1524     if(test_and_set_bit(QLA1280_IN_ISR_BIT, &ha->flags))
1525     {
1526         COMTRACE('X')
1527         spin_unlock_irqrestore(ha->host->host_lock, cpu_flags);
1528         return;
1529     }
1530     ha->isr_count++;
1531     reg = ha->iobase;
1532      /* disable our interrupt. */
1533     WRT_REG_WORD(&reg->ictrl, 0); 
1534     data = qla1280_debounce_register(&reg->istatus);
1535     /* Check for pending interrupts. */
1536     if ( !(data & RISC_INT) )
1537     {
1538         /* spurious interrupts can happen legally */
1539         DEBUG(printk("scsi(%d): Spurious interrupt - ignoring\n",(int)ha->host_no));
1540         COMTRACE('X')
1541     }
1542     else
1543       qla1280_isr(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1544     if (ha->done_q_first)
1545         qla1280_done(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1546
1547     clear_bit(QLA1280_IN_ISR_BIT, &ha->flags);
1548     spin_unlock_irqrestore(ha->host->host_lock, cpu_flags);
1549 #else  /* LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95) */
1550
1551     if( test_bit(QLA1280_IN_ISR_BIT, (int *)&ha->flags) )
1552     {
1553           COMTRACE('X')
1554           printk(KERN_INFO "scsi(%d): Already in interrupt - returning \n", (int)ha->host_no);
1555           return;
1556     }
1557     set_bit(QLA1280_IN_ISR_BIT, (int *)&ha->flags);
1558     ha->isr_count++;
1559     reg = ha->iobase;
1560      /* disable our interrupt. */
1561     WRT_REG_WORD(&reg->ictrl, 0); 
1562
1563     data = qla1280_debounce_register(&reg->istatus);
1564     /* Check for pending interrupts. */
1565     if ( !(data & RISC_INT) )
1566     {
1567         /* spurious interrupts can happen legally */
1568         DEBUG(printk("scsi(%d): Spurious interrupt - ignoring\n",(int)ha->host_no));
1569         COMTRACE('X')
1570     }
1571     else
1572      qla1280_isr(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1573
1574     /* if no work to do then call the SCSI mid-level right away */
1575     if( ha->done_q_first )
1576         qla1280_done(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1577
1578     /* Schedule the DPC routine */
1579     if (ha->flags.isp_abort_needed || ha->flags.reset_marker ||
1580             ha->done_q_first        )
1581         {
1582             ha->run_qla_bh.data = (void *) ha;
1583             ha->run_qla_bh.routine = qla1280_do_dpc; 
1584
1585              COMTRACE('P') 
1586             schedule_task(&ha->run_qla_bh);
1587             ha->flags.dpc_sched = TRUE;
1588         }
1589         clear_bit(QLA1280_IN_ISR_BIT, (int *)&ha->flags);
1590 #endif
1591      /* enable our interrupt. */
1592         WRT_REG_WORD(&reg->ictrl, ISP_EN_INT + ISP_EN_RISC);
1593
1594         COMTRACE('i')  
1595         LEAVE_INTR("qla1280_intr_handler");
1596 }
1597
1598 /**************************************************************************
1599  *   qla1280_do_dpc
1600  *
1601  * Description:
1602  * This routine is a task that is schedule by the interrupt handler 
1603  * to perform the background processing for interrupts.  We put it 
1604  * on a task queue that is consumed whenever the scheduler runs; that's
1605  * so you can do anything (i.e. put the process to sleep etc).  In fact, the 
1606  * mid-level tries to sleep when it reaches the driver threshold 
1607  * "host->can_queue". This can cause a panic if we were in our interrupt
1608  * code .
1609  **************************************************************************/
1610 static void qla1280_do_dpc(void *p)
1611 {
1612     scsi_qla_host_t *ha = (scsi_qla_host_t *) p;
1613 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
1614     unsigned long cpu_flags = 0;
1615 #endif
1616
1617     COMTRACE('p')  
1618 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
1619     spin_lock_irqsave(ha->host->host_lock, cpu_flags);
1620 #endif
1621     if (ha->flags.isp_abort_needed)
1622         qla1280_abort_isp(ha);
1623
1624     if (ha->flags.reset_marker)
1625         qla1280_rst_aen(ha);
1626
1627     if (ha->done_q_first)
1628         qla1280_done(ha, (srb_t **)&ha->done_q_first, (srb_t **)&ha->done_q_last);
1629     ha->flags.dpc_sched = FALSE;
1630 #if LINUX_VERSION_CODE > KERNEL_VERSION(2,1,95)
1631     spin_unlock_irqrestore(ha->host->host_lock, cpu_flags);
1632 #endif
1633 }
1634
1635 /**************************************************************************
1636  *   qla1280_device_queue_depth
1637  *
1638  * Description:
1639  *   Determines the queue depth for a given device.  There are two ways
1640  *   a queue depth can be obtained for a tagged queueing device.  One
1641  *   way is the default queue depth which is determined by whether
1642  *   If it is defined, then it is used
1643  *   as the default queue depth.  Otherwise, we use either 4 or 8 as the
1644  *   default queue depth (dependent on the number of hardware SCBs).
1645  **************************************************************************/
1646 STATIC void qla1280_device_queue_depth(scsi_qla_host_t *p, Scsi_Device *device)
1647 {
1648     int default_depth = 3;
1649     int bus = device->channel;
1650     int target = device->id;
1651
1652     device->queue_depth = default_depth;
1653
1654     if (device->tagged_supported &&
1655         (p->bus_settings[bus].qtag_enables & (BIT_0 << target)) )
1656     {
1657         device->tagged_queue = 1;
1658         device->current_tag = 0;
1659         device->queue_depth = p->bus_settings[bus].hiwat; 
1660         /* device->queue_depth = 20; */
1661         printk(KERN_INFO "scsi(%d:%d:%d:%d): Enabled tagged queuing, queue depth %d.\n",
1662                 (int)p->host_no, device->channel, device->id,
1663                 device->lun, device->queue_depth);
1664     }
1665     qla12160_get_target_parameters(p, bus, target, device->lun);
1666
1667 }
1668
1669 /**************************************************************************
1670  *   qla1280_select_queue_depth
1671  *
1672  *   Sets the queue depth for each SCSI device hanging off the input
1673  *   host adapter.  We use a queue depth of 2 for devices that do not
1674  *   support tagged queueing.
1675  **************************************************************************/
1676 STATIC void
1677 qla1280_select_queue_depth(struct Scsi_Host *host, Scsi_Device *scsi_devs)
1678 {
1679     Scsi_Device *device;
1680     scsi_qla_host_t  *p = (scsi_qla_host_t *) host->hostdata;
1681
1682     ENTER("qla1280_select_queue_depth");
1683     for (device = scsi_devs; device != NULL; device = device->next)
1684     {
1685         if (device->host == host)
1686             qla1280_device_queue_depth(p, device);
1687     }
1688     LEAVE("qla1280_select_queue_depth");
1689 }
1690
1691 /*--------------------------**
1692 ** Driver Support Routines  **
1693 **--------------------------*/
1694
1695 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,0)
1696 /*
1697  * mdelay
1698  *      Delay in milliseconds 
1699  *
1700  * Input:
1701  *      milliseconds  = delay 
1702  */
1703 STATIC inline void mdelay(int milliseconds)
1704 {
1705     int i;
1706
1707     for(i=0; i<milliseconds; i++)
1708         udelay(1000);
1709 }
1710 #endif
1711
1712 /*
1713  * qla1280_done
1714  *      Process completed commands.
1715  *
1716  * Input:
1717  *      ha           = adapter block pointer.
1718  *      done_q_first = done queue first pointer.
1719  *      done_q_last  = done queue last pointer.
1720  */
1721 STATIC void
1722 qla1280_done(scsi_qla_host_t *ha, srb_t **done_q_first, srb_t **done_q_last)
1723 {
1724     srb_t           *sp;
1725     scsi_lu_t       *q;
1726     uint32_t        b, t, l;
1727     Scsi_Cmnd  *cmd;
1728 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1729     unsigned long cpu_flags = 0;
1730 #endif
1731
1732     ENTER("qla1280_done");
1733     COMTRACE('D') 
1734
1735     DRIVER_LOCK 
1736     while (*done_q_first !=  NULL)
1737     {
1738         /* remove command from done list */
1739                 sp = *done_q_first;
1740         if (!(*done_q_first = sp->s_next))
1741             *done_q_last = NULL;
1742         else
1743             (*done_q_first)->s_prev = NULL;
1744                 cmd = sp->cmd;
1745         b = SCSI_BUS_32(cmd);
1746         t = SCSI_TCN_32(cmd);
1747         l = SCSI_LUN_32(cmd);
1748         q = LU_Q(ha, b, t, l);
1749
1750         /* Decrement outstanding commands on device. */
1751         if (q->q_outcnt)
1752             q->q_outcnt--;
1753         if (q->q_outcnt < ha->bus_settings[b].hiwat)
1754         {
1755             q->q_flag &= ~QLA1280_QBUSY;
1756         }
1757         
1758         q->resp_time += jiffies - sp->r_start;                /* Lun bookkeeping information */
1759         q->act_time += jiffies - sp->u_start;
1760         q->io_cnt++;
1761         if( sp->dir & BIT_5 )
1762          q->r_cnt++;
1763         else
1764          q->w_cnt++;
1765
1766         switch ( (CMD_RESULT(cmd)>>16))
1767         {
1768             case DID_RESET:
1769                 q->q_flag &= ~QLA1280_QRESET;
1770                 /* Issue marker command. */
1771                 qla1280_marker(ha, b, t, 0, MK_SYNC_ID); 
1772                 break;
1773             case DID_ABORT:
1774                 sp->flags &= ~SRB_ABORT_PENDING;
1775                 sp->flags |= SRB_ABORTED;
1776                 if (sp->flags & SRB_TIMEOUT)
1777                     CMD_RESULT(sp->cmd)= DID_TIME_OUT << 16;
1778                 break;
1779             default:
1780                 break;
1781         }
1782
1783         /* Call the mid-level driver interrupt handler */
1784         CMD_HANDLE(sp->cmd) = (unsigned char *) 0;
1785         ha->actthreads--;
1786 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1787         sti(); 
1788         (*(cmd)->scsi_done)(cmd);
1789         cli(); 
1790 #else
1791         (*(cmd)->scsi_done)(cmd);
1792 #endif
1793         qla1280_next(ha, q, b);
1794     }
1795     DRIVER_UNLOCK 
1796
1797
1798     COMTRACE('d') 
1799     LEAVE("qla1280_done");
1800 }
1801
1802 /*
1803  * Translates a ISP error to a Linux SCSI error
1804  */
1805 STATIC int qla1280_return_status( sts_entry_t *sts, Scsi_Cmnd       *cp)
1806 {
1807     int host_status = DID_ERROR;
1808 #if DEBUG_QLA1280_INTR
1809     STATIC char *reason[] =
1810     {
1811         "DID_OK",
1812                 "DID_NO_CONNECT",
1813                 "DID_BUS_BUSY",
1814                 "DID_TIME_OUT",
1815                 "DID_BAD_TARGET",
1816                 "DID_ABORT",
1817                 "DID_PARITY",
1818                 "DID_ERROR",
1819                 "DID_RESET",
1820                 "DID_BAD_INTR"
1821     };
1822 #endif /* DEBUG_QLA1280_INTR */
1823
1824     ENTER("qla1280_return_status");
1825
1826 #if DEBUG_QLA1280_INTR
1827     /*
1828     DEBUG(printk("qla1280_return_status: compl status = 0x%04x\n", sts->comp_status));
1829     */
1830 #endif
1831     switch(sts->comp_status)
1832     {
1833         case CS_COMPLETE:
1834             host_status = DID_OK;
1835             break;
1836         case CS_INCOMPLETE:
1837             if (!(sts->state_flags & SF_GOT_BUS))
1838                 host_status = DID_NO_CONNECT;
1839             else if (!(sts->state_flags & SF_GOT_TARGET))
1840                 host_status = DID_BAD_TARGET;
1841             else if (!(sts->state_flags & SF_SENT_CDB))
1842                 host_status = DID_ERROR;
1843             else if (!(sts->state_flags & SF_TRANSFERRED_DATA))
1844                 host_status = DID_ERROR;
1845             else if (!(sts->state_flags & SF_GOT_STATUS))
1846                 host_status = DID_ERROR;
1847             else if (!(sts->state_flags & SF_GOT_SENSE))
1848                 host_status = DID_ERROR;
1849             break;
1850         case CS_RESET:
1851             host_status = DID_RESET;
1852             break;
1853         case CS_ABORTED:
1854             host_status = DID_ABORT;
1855             break;
1856         case CS_TIMEOUT:
1857             host_status = DID_TIME_OUT;
1858             break;
1859         case CS_DATA_OVERRUN:
1860 #ifdef QL_DEBUG_LEVEL_2 
1861             printk("Data overrun 0x%x\n",(int)sts->residual_length);
1862             qla1280_print(
1863                         "\n\rqla1280_isr: response packet data\n\r");
1864                         qla1280_dump_buffer((caddr_t)sts,
1865                         RESPONSE_ENTRY_SIZE); 
1866 #endif
1867             host_status = DID_ERROR;
1868             break;
1869         case CS_DATA_UNDERRUN:
1870             if ( (CMD_XFRLEN(cp) - sts->residual_length) < cp->underflow)    
1871             { 
1872               printk("scsi: Underflow detected - retrying command.\n");
1873               host_status = DID_ERROR;
1874             }
1875             else
1876                 host_status = DID_OK;
1877             break;
1878         default:
1879             host_status = DID_ERROR;
1880             break;
1881     }
1882
1883 #if DEBUG_QLA1280_INTR
1884     sprintf(debug_buff, "qla1280 ISP status: host status (%s) scsi status %x\n\r", reason[host_status], sts->scsi_status);
1885     qla1280_print(debug_buff);
1886 #endif
1887
1888     LEAVE("qla1280_return_status");
1889
1890     return (sts->scsi_status & 0xff) | (host_status << 16);
1891 }
1892
1893 /*
1894  * qla1280_done_q_put
1895  *      Place SRB command on done queue.
1896  *
1897  * Input:
1898  *      sp           = srb pointer.
1899  *      done_q_first = done queue first pointer.
1900  *      done_q_last  = done queue last pointer.
1901  */
1902 STATIC void
1903 qla1280_done_q_put(srb_t *sp, srb_t **done_q_first, srb_t **done_q_last)
1904 {
1905 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1906     unsigned long cpu_flags = 0;
1907 #endif
1908 #ifdef QL_DEBUG_LEVEL_3
1909     ENTER("qla1280_put_done_q");
1910 #endif
1911     /* Place block on done queue */
1912     DRIVER_LOCK
1913             sp->s_next = NULL;
1914     sp->s_prev = *done_q_last;
1915     if (!*done_q_first)
1916         *done_q_first = sp;
1917     else
1918         (*done_q_last)->s_next = sp;
1919     *done_q_last = sp;
1920
1921     DRIVER_UNLOCK
1922 #ifdef QL_DEBUG_LEVEL_3
1923             LEAVE("qla1280_put_done_q");
1924 #endif
1925 }
1926
1927 /*
1928  * qla1280_next
1929  *      Retrieve and process next job in the queue.
1930  *
1931  * Input:
1932  *      ha = adapter block pointer.
1933  *      q  = SCSI LU pointer.
1934  *      b  = SCSI bus number.
1935  *      SCSI_LU_Q lock must be already obtained and no other locks.
1936  *
1937  * Output:
1938  *      Releases SCSI_LU_Q upon exit.
1939  */
1940 STATIC void
1941 qla1280_next(scsi_qla_host_t *ha, scsi_lu_t *q, uint8_t b)
1942 {
1943     srb_t   *sp;
1944     uint32_t cnt;
1945     uint8_t status;
1946 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
1947     unsigned long cpu_flags = 0;
1948 #endif
1949
1950     ENTER("qla1280_next");
1951
1952     DRIVER_LOCK
1953     while ( ((sp = q->q_first) != NULL) &&     /* we have a queue pending */
1954         !(q->q_flag &  QLA1280_QBUSY) &&      /* device not busy */
1955         !ha->flags.abort_isp_active &&      /* not resetting the adapter */
1956         !(q->q_flag & QLA1280_QSUSP) )      /* device not suspended */
1957     {
1958         /* Remove srb from SCSI LU queue. */
1959         qla1280_removeq(q, sp);
1960
1961         DEBUG(sprintf(debug_buff,"starting request 0x%p<-(0x%p)\n\r",q,sp));
1962         DEBUG(qla1280_print(debug_buff));
1963         {
1964             /* Set busy flag if reached high water mark. */
1965             q->q_outcnt++;
1966             if (q->q_outcnt >= ha->bus_settings[b].hiwat)
1967                 q->q_flag |= QLA1280_QBUSY;
1968
1969 #if  QLA1280_64BIT_SUPPORT
1970             if (ha->flags.enable_64bit_addressing)
1971                 status = qla1280_64bit_start_scsi(ha, sp);
1972             else
1973 #endif
1974                 status = qla1280_32bit_start_scsi(ha, sp);
1975
1976             if (status)  /* if couldn't start the request */
1977             {
1978                 if (q->q_outcnt == 1)
1979                 {
1980                     /* Release SCSI LU queue specific lock */
1981                     QLA1280_SCSILU_UNLOCK(q);
1982
1983                     /* Wait for 30 sec for command to be accepted. */
1984                     for (cnt = 6000000; cnt; cnt--)
1985                     {
1986 #if  QLA1280_64BIT_SUPPORT
1987                         if (ha->flags.enable_64bit_addressing)
1988                             status = qla1280_64bit_start_scsi(ha, sp);
1989                         else
1990 #endif
1991                             status = qla1280_32bit_start_scsi(ha, sp);
1992
1993                         if (!status)
1994                         {
1995                             break;
1996                         }
1997
1998                         /* Go check for pending interrupts. */
1999                         qla1280_poll(ha);
2000
2001                         SYS_DELAY(5);  /* 10 */
2002                     }
2003                     if (!cnt)
2004                     {
2005                         /* Set timeout status */
2006                         CMD_RESULT(sp->cmd) = DID_TIME_OUT << 16;
2007
2008 #if WATCHDOGTIMER
2009                         /* Remove command from watchdog queue. */
2010                         if (sp->flags & SRB_WATCHDOG)
2011                             qla1280_timeout_remove(ha, sp);
2012 #endif
2013                         COMTRACE('M') 
2014                         CMD_HANDLE(sp->cmd) = (unsigned char *) 0;
2015
2016                         /* Call the mid-level driver interrupt handler */
2017 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2018                         sti(); 
2019                         (*(sp->cmd)->scsi_done)(sp->cmd);
2020                         cli(); 
2021 #else
2022                         (*(sp->cmd)->scsi_done)(sp->cmd);
2023 #endif
2024
2025                         /* Acquire LU queue specific lock */
2026                         QLA1280_SCSILU_LOCK(q);
2027
2028                         if (q->q_outcnt)
2029                             q->q_outcnt--;
2030                     }
2031                     else
2032                         /* Acquire LU queue specific lock */
2033                         QLA1280_SCSILU_LOCK(q);
2034                 }
2035                 else
2036                 {   /* Place request back on top of device queue. */
2037                     qla1280_putq_t(q, sp);
2038
2039                     if (q->q_outcnt)
2040                         q->q_outcnt--;
2041                     if (q->q_outcnt < ha->bus_settings[b].hiwat)
2042                         q->q_flag &= ~QLA1280_QBUSY;
2043                     break;
2044                 }
2045             }
2046         }
2047     }
2048    DRIVER_UNLOCK
2049
2050     /* Release SCSI LU queue specific lock */
2051     QLA1280_SCSILU_UNLOCK(q);
2052
2053     LEAVE("qla1280_next");
2054 }
2055
2056 /*
2057  * qla1280_putq_t
2058  *      Add the standard SCB job to the top of standard SCB commands.
2059  *
2060  * Input:
2061  *      q  = SCSI LU pointer.
2062  *      sp = srb pointer.
2063  *      SCSI_LU_Q lock must be already obtained.
2064  */
2065 STATIC void
2066 qla1280_putq_t(scsi_lu_t *q, srb_t *sp)
2067 {
2068     srb_t *srb_p;
2069 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2070     unsigned long cpu_flags = 0;
2071 #endif
2072
2073 #ifdef QL_DEBUG_LEVEL_3
2074     ENTER("qla1280_putq_t");
2075 #endif
2076     DRIVER_LOCK
2077     DEBUG(sprintf(debug_buff,"Adding to device 0x%p<-(0x%p)\n\r",q,sp));
2078     DEBUG(qla1280_print(debug_buff));
2079     sp->s_next = NULL;
2080     if (!q->q_first)                  /* If queue empty */
2081     {
2082         sp->s_prev = NULL;
2083         q->q_first = sp;
2084         q->q_last = sp;
2085     }
2086     else
2087     {      
2088         srb_p = q->q_first;
2089         while (srb_p )
2090             srb_p = srb_p->s_next;
2091
2092         if (srb_p)
2093         {
2094             sp->s_prev = srb_p->s_prev;
2095             if (srb_p->s_prev)
2096                 srb_p->s_prev->s_next = sp;
2097             else
2098                 q->q_first = sp;
2099             srb_p->s_prev = sp;
2100             sp->s_next = srb_p;
2101         }
2102         else
2103         {
2104             sp->s_prev = q->q_last;
2105             q->q_last->s_next = sp;
2106             q->q_last = sp;
2107         }
2108     }
2109
2110     DRIVER_UNLOCK
2111 #ifdef QL_DEBUG_LEVEL_3
2112             LEAVE("qla1280_putq_t");
2113 #endif
2114 }
2115
2116 /*
2117  * qla1280_removeq
2118  *      Function used to remove a command block from the
2119  *      LU queue.
2120  *
2121  * Input:
2122  *      q  = SCSI LU pointer.
2123  *      sp = srb pointer.
2124  *      SCSI_LU_Q lock must be already obtained.
2125  */
2126 STATIC void
2127 qla1280_removeq(scsi_lu_t *q, srb_t *sp)
2128 {
2129 #if LINUX_VERSION_CODE < KERNEL_VERSION(2,1,95)
2130     unsigned long cpu_flags = 0;
2131 #endif
2132     DEBUG(sprintf(debug_buff,"Removing from device_q (0x%p)->(0x%p)\n\r",q,sp));
2133     DEBUG(qla1280_print(debug_buff));
2134     DRIVER_LOCK
2135             if (sp->s_prev)
2136     {
2137         if ((sp->s_prev->s_next = sp->s_next) != NULL)
2138             sp->s_next->s_prev = sp->s_prev;
2139         else
2140             q->q_last = sp->s_prev;
2141     }
2142     else if (!(q->q_first = sp->s_next))
2143         q->q_last = NULL;
2144     else
2145         q->q_first->s_prev = NULL;
2146     DRIVER_UNLOCK
2147 }
2148
2149 /*
2150 * qla1280_mem_alloc
2151 *      Allocates adapter memory.
2152 *
2153 * Returns:
2154 *      0  = success.
2155 *      1  = failure.
2156 */
2157 STATIC uint8_t
2158 qla1280_mem_alloc(scsi_qla_host_t *ha)
2159 {
2160
2161         uint8_t   status = 1;
2162
2163 #ifdef QL_DEBUG_LEVEL_3
2164         ENTER("qla1280_mem_alloc");
2165 #endif
2166
2167 #ifdef DYNAMIC_MEM_ALLOC
2168         ha->request_ring = qla1280_alloc_phys(REQUEST_ENTRY_SIZE * REQUEST_ENTRY_CNT,
2169         &ha->request_dma);
2170         if(ha->request_ring) {
2171                 ha->response_ring = qla1280_alloc_phys(RESPONSE_ENTRY_SIZE * RESPONSE_ENTRY_CNT,
2172                 &ha->response_dma);
2173                 if(ha->response_ring) {
2174                         status = 0;
2175                 }
2176         }
2177 #else
2178         ha->request_ring = &ha->req[0];
2179         ha->request_dma = VIRT_TO_BUS(&ha->req[0]);
2180         ha->response_ring = &ha->res[0];
2181         ha->response_dma = VIRT_TO_BUS(&ha->res[0]);
2182         status = 0;
2183 #endif
2184
2185         if(status) {
2186 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2187                 qla1280_print("qla1280_mem_alloc: **** FAILED ****\n");
2188 #endif
2189         }
2190 #ifdef QL_DEBUG_LEVEL_3
2191         else
2192                 LEAVE("qla1280_mem_alloc");
2193 #endif
2194         return(status);
2195 }
2196
2197 /*
2198  * qla1280_mem_free
2199  *      Frees adapter allocated memory.
2200  *
2201  * Input:
2202  *      ha = adapter block pointer.
2203  */
2204 STATIC void
2205 qla1280_mem_free(scsi_qla_host_t *ha)
2206 {
2207     scsi_lu_t *q;
2208     uint32_t  b, t, l;
2209
2210     ENTER("qlc1280_mem_free");
2211     if (ha)
2212     {
2213         /* Free device queues. */
2214         for (b = 0; b < MAX_BUSES; b++)
2215         {
2216             q = LU_Q(ha, b, ha->bus_settings[b].id, 0);
2217             for (t = 0; t < MAX_TARGETS; t++)
2218                 for (l = 0; l < MAX_LUNS; l++)
2219                     if (LU_Q(ha, b, t, l) != NULL && LU_Q(ha, b, t, l) != q)
2220                         KMFREE(LU_Q(ha, b, t, l),sizeof(struct scsi_lu));
2221                     KMFREE(q, sizeof(struct scsi_lu));
2222         }
2223         for( b =0; b < MAX_EQ; b++ )
2224             ha->dev[b] =  (scsi_lu_t  *)NULL;
2225     }
2226
2227     LEAVE("qlc1280_mem_free");
2228 }
2229
2230
2231
2232
2233 /****************************************************************************/
2234 /*                QLogic ISP1280 Hardware Support Functions.                */
2235 /****************************************************************************/
2236
2237  /*
2238  * qla2100_enable_intrs
2239  * qla2100_disable_intrs
2240  *
2241  * Input:
2242  *      ha = adapter block pointer.
2243  *
2244  * Returns:
2245  *      None      
2246  */
2247     static inline void qla1280_enable_intrs(scsi_qla_host_t *ha) {
2248         device_reg_t *reg;
2249
2250         reg = ha->iobase;
2251         ha->flags.interrupts_on = 1;
2252         /* enable risc and host interrupts */
2253         WRT_REG_WORD(&reg->ictrl, (ISP_EN_INT+ ISP_EN_RISC));
2254     }
2255
2256     static inline void qla1280_disable_intrs(scsi_qla_host_t *ha) {
2257         device_reg_t *reg;
2258
2259         reg = ha->iobase;
2260         ha->flags.interrupts_on = 0;
2261         /* disable risc and host interrupts */
2262         WRT_REG_WORD(&reg->ictrl, 0);
2263     }
2264
2265 /*
2266  * qla1280_initialize_adapter
2267  *      Initialize board.
2268  *
2269  * Input:
2270  *      ha = adapter block pointer.
2271  *
2272  * Returns:
2273  *      0 = success
2274  */
2275 STATIC uint8_t
2276 qla1280_initialize_adapter(scsi_qla_host_t *ha)
2277 {
2278     device_reg_t *reg;
2279     uint8_t      status;
2280     /* uint8_t      cnt; */
2281     uint8_t      b;
2282
2283 #ifdef QL_DEBUG_LEVEL_3
2284     ENTER("qla1280_initialize_adapter");
2285 #endif
2286
2287     /* Clear adapter flags. */
2288     ha->flags.online = FALSE;
2289     ha->flags.isp_abort_needed = FALSE;
2290     ha->flags.disable_host_adapter = FALSE;
2291     ha->flags.reset_active = FALSE;
2292     ha->flags.abort_isp_active = FALSE;
2293     ha->flags.watchdog_enabled = FALSE;
2294
2295     DEBUG(printk("Configure PCI space for adapter...\n"));
2296     if (!(status = qla1280_pci_config(ha)))
2297     {
2298         reg = ha->iobase;
2299
2300         /* Disable ISP interrupts. */
2301         WRT_REG_WORD(&reg->ictrl, 0);
2302
2303         /* Insure mailbox registers are free. */
2304         WRT_REG_WORD(&reg->semaphore, 0);
2305         WRT_REG_WORD(&reg->host_cmd, HC_CLR_RISC_INT);
2306         WRT_REG_WORD(&reg->host_cmd, HC_CLR_HOST_INT);
2307
2308         /* If firmware needs to be loaded */
2309         if (qla1280_verbose)
2310          printk("scsi(%d): Determining if RISC is loaded...\n",(int)ha->host_no);
2311         if (qla1280_isp_firmware(ha))
2312         {
2313             if (qla1280_verbose)
2314               printk("scsi(%d): Verifying chip...\n",(int)ha->host_no);
2315             if (!(status = qla1280_chip_diag(ha)))
2316             {
2317                 if (qla1280_verbose)
2318                   printk("scsi(%d): Setup chip...\n",(int)ha->host_no);
2319                 status = qla1280_setup_chip(ha); 
2320             }
2321         }
2322
2323         if (!status)
2324         {
2325             /* Setup adapter based on NVRAM parameters. */
2326             if (qla1280_verbose)
2327               printk("scsi(%d): Configure NVRAM parameters...\n",(int)ha->host_no);
2328             qla1280_nvram_config(ha);
2329
2330             if (!ha->flags.disable_host_adapter &&
2331                 !qla1280_init_rings(ha))
2332             {
2333                 /* Issue SCSI reset. */
2334                 for (b = 0; b < ha->ports; b++)
2335                     if (!ha->bus_settings[b].disable_scsi_reset)
2336                     {
2337                       /* dg 03/13 if we can't reset twice then bus is dead */
2338                         if( qla1280_bus_reset(ha, b) )
2339                            if( qla1280_bus_reset(ha, b) )
2340                            {
2341                                ha->bus_settings[b].scsi_bus_dead = TRUE;
2342                             }
2343                     }
2344
2345                     do
2346                     {
2347                         /* Issue marker command. */
2348                         ha->flags.reset_marker = FALSE;
2349                         for (b = 0; b < ha->ports; b++)
2350                         {
2351                             ha->bus_settings[b].reset_marker = FALSE;
2352                             qla1280_marker(ha, b, 0, 0, MK_SYNC_ALL);
2353                         }
2354                     }while (ha->flags.reset_marker);
2355
2356                     ha->flags.online = TRUE;
2357
2358                     /* Enable host adapter target mode. */
2359                     for (b = 0; b < ha->ports; b++)
2360                     {
2361                         if (!(status = qla1280_enable_tgt(ha, b)))
2362                         {
2363                             /* for (cnt = 0; cnt < MAX_LUNS; cnt++)
2364                             {
2365                                 qla1280_enable_lun(ha, b, cnt);
2366                                  qla1280_poll(ha);
2367                             }*/
2368                         }
2369                         else
2370                             break;
2371                     }
2372             }
2373             else
2374                 status = 1;
2375         }
2376     }
2377
2378 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2379     if (status)
2380         qla1280_print("qla1280_initialize_adapter: **** FAILED ****\n\r");
2381 #endif
2382 #ifdef QL_DEBUG_LEVEL_3
2383     else
2384         LEAVE("qla1280_initialize_adapter");
2385 #endif
2386     return(status);
2387 }
2388
2389 /*
2390  * qla1280_enable_tgt
2391  *      Enable target mode.
2392  *
2393  * Input:
2394  *      ha = adapter block pointer.
2395  *      b  = SCSI bus number.
2396  *
2397  * Returns:
2398  *      0 = success.
2399  */
2400 STATIC uint8_t
2401 qla1280_enable_tgt(scsi_qla_host_t *ha, uint8_t b)
2402 {
2403     uint8_t     status = 0;
2404     /*  uint16_t    mb[MAILBOX_REGISTER_COUNT]; */
2405
2406 #ifdef QL_DEBUG_LEVEL_3
2407     qla1280_print("qla1280_enable_tgt: entered\n\r");
2408 #endif
2409
2410     /* Enable target mode. */
2411     /*
2412     mb[0] = MBC_ENABLE_TARGET_MODE;
2413     mb[1] = BIT_15;
2414     mb[2] = (uint16_t)(b << 15);
2415     status = qla1280_mailbox_command(ha, BIT_2|BIT_1|BIT_0, &mb[0]);
2416     */
2417 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2418     if (status)
2419         qla1280_print("qla1280_enable_tgt: **** FAILED ****\n\r");
2420 #endif
2421 #ifdef QL_DEBUG_LEVEL_3
2422     else
2423         qla1280_print("qla1280_enable_tgt: exiting normally\n\r");
2424 #endif
2425     return(status);
2426 }
2427
2428 /*
2429  * ISP Firmware Test
2430  *      Checks if present version of RISC firmware is older than
2431  *      driver firmware.
2432  *
2433  * Input:
2434  *      ha = adapter block pointer.
2435  *
2436  * Returns:
2437  *      0 = firmware does not need to be loaded.
2438  */
2439 STATIC uint8_t
2440 qla1280_isp_firmware(scsi_qla_host_t *ha)
2441 {
2442     nvram_t     *nv    = (nvram_t *)ha->response_ring; 
2443     uint16_t    *wptr;
2444     uint8_t     chksum;
2445     uint8_t     cnt;
2446     uint8_t     status = 0;    /* dg 2/27 always loads RISC */
2447     uint16_t    mb[MAILBOX_REGISTER_COUNT];
2448
2449     ENTER("qla1280_isp_firmware");
2450
2451     /* Verify valid NVRAM checksum. */
2452     wptr = (uint16_t *)ha->response_ring;
2453     DEBUG(printk("qla1280_isp_firmware: Reading NVRAM\n"));
2454     chksum = 0;
2455     for (cnt = 0; cnt < sizeof(nvram_t)/2; cnt++)
2456     {
2457         *wptr = qla1280_get_nvram_word(ha, cnt);
2458         chksum += (uint8_t)*wptr;
2459         chksum += (uint8_t)(*wptr >> 8);
2460         wptr++;
2461     }
2462     DEBUG(printk("qla1280_isp_firmware: Completed Reading NVRAM\n"));
2463
2464 #if defined(QL_DEBUG_LEVEL_3)
2465     sprintf(debug_buff,"qla1280_isp_firmware: NVRAM Magic ID= %c %c %c\n\r",(char *) nv->id[0],nv->id[1],nv->id[2]);
2466     qla1280_print(debug_buff);
2467 #endif
2468
2469     /* Bad NVRAM data, load RISC code. */
2470     if (chksum || nv->id[0] != 'I' || nv->id[1] != 'S' ||
2471         nv->id[2] != 'P' || nv->id[3] != ' ' || nv->version < 1)
2472     {
2473         printk(KERN_INFO "qla1280_isp_firmware: Bad checksum or magic number or version in NVRAM.\n");
2474         ha->flags.disable_risc_code_load = FALSE;
2475     }
2476     else
2477         ha->flags.disable_risc_code_load = nv->cntr_flags_1.disable_loading_risc_code;
2478
2479     if (ha->flags.disable_risc_code_load)
2480     {
2481 #if defined(QL_DEBUG_LEVEL_3)
2482         qla1280_print("qla1280_isp_firmware: Telling RISC to verify checksum of loaded BIOS code.\n\r");
2483 #endif
2484         /* Verify checksum of loaded RISC code. */
2485         mb[0] = MBC_VERIFY_CHECKSUM;
2486         /* mb[1] = ql12_risc_code_addr01; */
2487         mb[1] = *QLBoardTbl[ha->devnum].fwstart;  
2488
2489         if (!(status = qla1280_mailbox_command(ha, BIT_1|BIT_0, &mb[0])))
2490         {
2491             /* Start firmware execution. */
2492 #if defined(QL_DEBUG_LEVEL_3)
2493             qla1280_print("qla1280_isp_firmware: Startng F/W execution.\n\r");
2494 #endif
2495             mb[0] = MBC_EXECUTE_FIRMWARE;
2496             /* mb[1] = ql12_risc_code_addr01; */
2497             mb[1] = *QLBoardTbl[ha->devnum].fwstart;  
2498             qla1280_mailbox_command(ha, BIT_1|BIT_0, &mb[0]);
2499         }
2500         else
2501             printk(KERN_INFO "qla1280: RISC checksum failed.\n");
2502     }
2503     else
2504     {
2505         DEBUG(printk("qla1280: NVRAM configured to load RISC load.\n"));
2506         status = 1;
2507      }
2508
2509 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2510     if (status)
2511         qla1280_print(
2512                 "qla1280_isp_firmware: **** Load RISC code ****\n\r");
2513 #endif
2514     LEAVE("qla1280_isp_firmware");
2515     return(status);
2516 }
2517
2518 /*
2519  * PCI configuration
2520  *      Setup device PCI configuration registers.
2521  *
2522  * Input:
2523  *      ha = adapter block pointer.
2524  *
2525  * Returns:
2526  *      0 = success.
2527  */
2528 STATIC uint8_t
2529 qla1280_pci_config(scsi_qla_host_t *ha)
2530 {
2531     uint8_t      status = 1;
2532     uint32_t     command;
2533 #if MEMORY_MAPPED_IO
2534     uint32_t  page_offset, base;
2535     uint32_t   mmapbase;
2536 #endif
2537     config_reg_t *creg = 0;
2538     uint16_t     buf_wd;
2539
2540     ENTER("qla1280_pci_config");
2541
2542     /* Get command register. */
2543     if (pci_read_config_word(ha->pdev,OFFSET(creg->command), &buf_wd) == PCIBIOS_SUCCESSFUL)
2544     {
2545         command = buf_wd;
2546         /*
2547         * Set Bus Master Enable, Memory Address Space Enable and
2548         * reset any error bits.
2549         */
2550         buf_wd &= ~0x7;
2551 #if MEMORY_MAPPED_IO
2552         DEBUG(printk("qla1280: MEMORY MAPPED IO is enabled.\n"));
2553         buf_wd |= BIT_2 + BIT_1 + BIT_0;
2554 #else
2555         buf_wd |= BIT_2 + BIT_0;
2556 #endif
2557         if( pci_write_config_word(ha->pdev,OFFSET(creg->command), buf_wd) )
2558         {
2559             printk(KERN_WARNING "qla1280: Could not write config word.\n");
2560         }
2561         /* Get expansion ROM address. */
2562         if (pci_read_config_word(ha->pdev,OFFSET(creg->expansion_rom), &buf_wd) == PCIBIOS_SUCCESSFUL)
2563         {
2564             /* Reset expansion ROM address decode enable. */
2565             buf_wd &= ~BIT_0;
2566             if (pci_write_config_word(ha->pdev,OFFSET(creg->expansion_rom), buf_wd) == PCIBIOS_SUCCESSFUL)
2567             {
2568 #if MEMORY_MAPPED_IO
2569                 /* Get memory mapped I/O address. */
2570                 pci_read_config_dword(ha->pdev,OFFSET(cfgp->mem_base_addr), &mmapbase);
2571                 mmapbase &= PCI_BASE_ADDRESS_MEM_MASK;
2572
2573                 /* Find proper memory chunk for memory map I/O reg. */
2574                 base = mmapbase & PAGE_MASK;
2575                 page_offset = mmapbase - base;
2576                 /* Get virtual address for I/O registers. */
2577 #if LINUX_VERSION_CODE >= KERNEL_VERSION(2,1,0)
2578                 ha->mmpbase = ioremap_nocache(base, page_offset + 256);
2579 #else
2580                 ha->mmpbase = vremap(base,page_offset + 256);
2581 #endif
2582                 if( ha->mmpbase )
2583                 {
2584                     ha->mmpbase += page_offset;
2585                     /* ha->iobase = ha->mmpbase; */
2586                     status = 0;
2587                 }
2588 #else /* MEMORY_MAPPED_IO */
2589                 status = 0;
2590 #endif /* MEMORY_MAPPED_IO */
2591             }
2592         }
2593     }
2594
2595     LEAVE("qla1280_pci_config");
2596     return(status);
2597 }
2598
2599 /*
2600  * Chip diagnostics
2601  *      Test chip for proper operation.
2602  *
2603  * Input:
2604  *      ha = adapter block pointer.
2605  *
2606  * Returns:
2607  *      0 = success.
2608  */
2609 STATIC uint8_t
2610 qla1280_chip_diag(scsi_qla_host_t *ha)
2611 {
2612     device_reg_t *reg   = ha->iobase;
2613     uint8_t      status = 0;
2614     uint16_t     data;
2615     uint32_t     cnt;
2616     uint16_t     mb[MAILBOX_REGISTER_COUNT];
2617
2618 #ifdef QL_DEBUG_LEVEL_3
2619     sprintf(debug_buff, "qla1280_chip_diag: testing device at 0x%p \n\r",&reg->id_l);
2620     qla1280_print(debug_buff);
2621 #endif
2622
2623     /* Soft reset chip and wait for it to finish. */
2624     WRT_REG_WORD(&reg->ictrl, ISP_RESET); 
2625     data = qla1280_debounce_register(&reg->ictrl);
2626     for (cnt = 6000000; cnt && data & ISP_RESET; cnt--)
2627     {
2628         SYS_DELAY(5);
2629         data = RD_REG_WORD(&reg->ictrl);
2630     }
2631     if (cnt)
2632     {
2633         /* Reset register not cleared by chip reset. */
2634 #if defined(QL_DEBUG_LEVEL_3)
2635         qla1280_print("qla1280_chip_diag: reset register cleared by chip reset\n\r");
2636 #endif
2637         WRT_REG_WORD(&reg->cfg_1, 0);
2638
2639         /* Reset RISC and disable BIOS which
2640         allows RISC to execute out of RAM. */
2641         WRT_REG_WORD(&reg->host_cmd, HC_RESET_RISC);
2642         WRT_REG_WORD(&reg->host_cmd, HC_RELEASE_RISC);
2643         WRT_REG_WORD(&reg->host_cmd, HC_DISABLE_BIOS);
2644         data = qla1280_debounce_register(&reg->mailbox0);
2645         for (cnt = 6000000; cnt && data == MBS_BUSY; cnt--)
2646         {
2647             SYS_DELAY(5);
2648             data = RD_REG_WORD(&reg->mailbox0);
2649         }
2650
2651         if (cnt)
2652         {
2653             /* Check product ID of chip */
2654 #if defined(QL_DEBUG_LEVEL_3)
2655             qla1280_print("qla1280_chip_diag: Checking product ID of chip\n\r");
2656 #endif
2657             if (RD_REG_WORD(&reg->mailbox1) != PROD_ID_1 ||
2658                 (RD_REG_WORD(&reg->mailbox2) != PROD_ID_2 &&
2659                 RD_REG_WORD(&reg->mailbox2) != PROD_ID_2a) ||
2660                 RD_REG_WORD(&reg->mailbox3) != PROD_ID_3 ||
2661                 RD_REG_WORD(&reg->mailbox4) != PROD_ID_4)
2662             {
2663                 printk(KERN_INFO "qla1280: Wrong product ID = 0x%x,0x%x,0x%x,0x%x\n",
2664                         RD_REG_WORD(&reg->mailbox1),
2665                         RD_REG_WORD(&reg->mailbox2),
2666                         RD_REG_WORD(&reg->mailbox3),
2667                         RD_REG_WORD(&reg->mailbox4) );
2668                 status = 1;
2669             }
2670             else
2671             {
2672                 DEBUG(printk("qla1280_chip_diag: Checking mailboxes of chip\n"));
2673                 /* Wrap Incoming Mailboxes Test. */
2674                 mb[0] = MBC_MAILBOX_REGISTER_TEST;
2675                 mb[1] = 0xAAAA;
2676                 mb[2] = 0x5555;
2677                 mb[3] = 0xAA55;
2678                 mb[4] = 0x55AA;
2679                 mb[5] = 0xA5A5;
2680                 mb[6] = 0x5A5A;
2681                 mb[7] = 0x2525;
2682                 if (!(status = qla1280_mailbox_command(ha,
2683                     (BIT_7|BIT_6|BIT_5|BIT_4|BIT_3|BIT_2|BIT_1|BIT_0),
2684                     &mb[0])))
2685                 {
2686                     if (mb[1] != 0xAAAA || mb[2] != 0x5555 ||
2687                         mb[3] != 0xAA55 || mb[4] != 0x55AA)
2688                         status = 1;
2689                     if (mb[5] != 0xA5A5 || mb[6] != 0x5A5A ||
2690                         mb[7] != 0x2525)
2691                         status = 1;
2692                     if( status == 1 )
2693                         printk(KERN_INFO "qla1280: Failed mailbox check\n");
2694                 }
2695             }
2696         }
2697         else
2698             status = 1;
2699     }
2700     else
2701         status = 1;
2702
2703 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2704     if (status)
2705         qla1280_print("qla1280_chip_diag: **** FAILED ****\n\r");
2706 #endif
2707 #ifdef QL_DEBUG_LEVEL_3
2708     else
2709         qla1280_print("qla1280_chip_diag: exiting normally\n\r");
2710 #endif
2711     return(status);
2712 }
2713
2714 /*
2715  * Setup chip
2716  *      Load and start RISC firmware.
2717  *
2718  * Input:
2719  *      ha = adapter block pointer.
2720  *
2721  * Returns:
2722  *      0 = success.
2723  */
2724 STATIC uint8_t
2725 qla1280_setup_chip(scsi_qla_host_t *ha)
2726 {
2727     uint8_t      status = 0;
2728     uint16_t     risc_address;
2729     uint16_t     *risc_code_address;
2730     long         risc_code_size;
2731     uint16_t     mb[MAILBOX_REGISTER_COUNT];
2732 #ifdef QLA1280_UNUSED
2733     uint8_t     *sp;
2734     int i;
2735 #endif
2736     uint16_t     cnt;
2737     int          num;
2738     uint8_t    *tbuf;
2739     u_long     p_tbuf;
2740
2741 #ifdef QL_DEBUG_LEVEL_3
2742     ENTER("qla1280_setup_chip");
2743 #endif
2744
2745         if( (tbuf = (uint8_t *)KMALLOC(8000) ) == NULL )
2746         {
2747             printk("setup_chip: couldn't alloacte memory\n");
2748             return(1);
2749         }
2750         p_tbuf =  VIRT_TO_BUS(tbuf);
2751     /* Load RISC code. */
2752     /* 
2753     risc_address      = ql12_risc_code_addr01;
2754     risc_code_address = &ql12_risc_code01[0];
2755     risc_code_size    = ql12_risc_code_length01;
2756     */
2757     risc_address = *QLBoardTbl[ha->devnum].fwstart;  
2758     risc_code_address = QLBoardTbl[ha->devnum].fwcode;  
2759     risc_code_size    = (long)(*QLBoardTbl[ha->devnum].fwlen & 0xffff);  
2760
2761     DEBUG(printk("qla1280: DMAing RISC code (%d) words.\n",(int)risc_code_size));
2762     DEBUG(sprintf(debug_buff,"qla1280_setup_chip:  Loading RISC code size =(%ld).\n\r",risc_code_size);)
2763     DEBUG(qla1280_print(debug_buff));
2764     num =0;
2765     while (risc_code_size > 0 && !status)
2766     {
2767         cnt = 2000 >> 1;
2768
2769         if ( cnt > risc_code_size ) 
2770             cnt = risc_code_size;
2771
2772         DEBUG(sprintf(debug_buff,"qla1280_setup_chip:  loading risc @ =(0x%p),%d,%d(0x%x).\n\r",risc_code_address,cnt,num,risc_address);)
2773         DEBUG(qla1280_print(debug_buff));
2774         DEBUG(printk("qla1280_setup_chip:  loading risc @ =code=(0x%p),cnt=%d,seg=%d,addr=0x%x\n\r",risc_code_address,cnt,num,risc_address));
2775         BCOPY((caddr_t) risc_code_address,(caddr_t) ha->request_ring, (cnt <<1));
2776         mb[0] = MBC_LOAD_RAM; 
2777         /* mb[0] = MBC_LOAD_RAM_A64; */
2778         mb[1] = risc_address;
2779         mb[4] = cnt;
2780         mb[3] = (uint16_t)  ha->request_dma & 0xffff;
2781         mb[2] = (uint16_t) (ha->request_dma >> 16) & 0xffff;
2782         mb[7] = (uint16_t) (MS_64BITS(ha->request_dma) & 0xffff);
2783         mb[6] = (uint16_t) (MS_64BITS(ha->request_dma) >> 16) & 0xffff;
2784         DEBUG(printk("qla1280_setup_chip: op=%d  0x%lx = 0x%4x,0x%4x,0x%4x,0x%4x\n",mb[0],ha->request_dma,mb[6],mb[7],mb[2],mb[3]));
2785         if( (status = qla1280_mailbox_command(ha, BIT_4|BIT_3|BIT_2|BIT_1|BIT_0,
2786             &mb[0]))  )
2787         {
2788             printk("Failed to load partial segment of f/w\n");
2789             break;
2790         }
2791         /* dump it back */
2792
2793 #if 0
2794         mb[0] = MBC_DUMP_RAM_A64;
2795         mb[1] = risc_address;
2796         mb[4] = cnt;
2797         mb[3] = (uint16_t)  p_tbuf & 0xffff;
2798         mb[2] = (uint16_t) (p_tbuf >> 16) & 0xffff;
2799         mb[7] = (uint16_t) (p_tbuf >> 32) & 0xffff;
2800         mb[6] = (uint16_t) (p_tbuf >> 48) & 0xffff;
2801
2802         if( (status = qla1280_mailbox_command(ha, BIT_4|BIT_3|BIT_2|BIT_1|BIT_0,
2803             &mb[0]))  )
2804         {
2805             printk("Failed to dump partial segment of f/w\n");
2806             break;
2807         }
2808         sp =  (uint8_t *)ha->request_ring;
2809         for (i = 0; i < (cnt<< 1) ; i++)
2810         {
2811             if( tbuf[i] != sp[i] )
2812             {
2813                printk("qla1280 : firmware compare error @ byte (0x%x)\n",i);
2814                 break;
2815             }
2816         }
2817
2818 #endif
2819         risc_address += cnt;
2820         risc_code_size = risc_code_size - cnt;
2821         risc_code_address = risc_code_address + cnt;
2822         num++;
2823     }
2824 #ifdef QLA1280_UNUSED
2825     DEBUG(ql_debug_print = 0;)
2826     {
2827         for (i = 0; i < ql12_risc_code_length01; i++)
2828         {
2829             mb[0] = 0x4;
2830             mb[1] = ql12_risc_code_addr01 + i;
2831             mb[2] = ql12_risc_code01[i];
2832
2833             status = qla1280_mailbox_command(ha, BIT_2|BIT_1|BIT_0,
2834                     &mb[0]);
2835             if (status)
2836             {
2837                 printk("qla1280 : firmware load failure\n");
2838                 break;
2839             }
2840
2841             mb[0] = 0x5;
2842             mb[1] = ql12_risc_code_addr01 + i;
2843             mb[2] = 0;
2844
2845             status = qla1280_mailbox_command(ha, BIT_2|BIT_1|BIT_0,
2846                     &mb[0]);
2847             if (status)
2848             {
2849                 printk("qla1280 : firmware dump failure\n");
2850                 break;
2851             }
2852             if( mb[2] != ql12_risc_code01[i] )
2853                 printk("qla1280 : firmware compare error @ (0x%x)\n",ql12_risc_code_addr01+i);
2854         }
2855     }
2856     DEBUG(ql_debug_print = 1;)
2857 #endif
2858
2859     /* Verify checksum of loaded RISC code. */
2860     if (!status)
2861     {
2862         DEBUG(printk("qla1280_setup_chip: Verifying checksum of loaded RISC code.\n");)
2863         mb[0] = MBC_VERIFY_CHECKSUM;
2864         /* mb[1] = ql12_risc_code_addr01; */
2865         mb[1] = *QLBoardTbl[ha->devnum].fwstart;  
2866         
2867         if (!(status = qla1280_mailbox_command(ha, BIT_1|BIT_0, &mb[0])))
2868         {
2869             /* Start firmware execution. */
2870             DEBUG(qla1280_print("qla1280_setup_chip: start firmware running.\n\r");)
2871             mb[0] = MBC_EXECUTE_FIRMWARE;
2872             /* mb[1] = ql12_risc_code_addr01; */
2873             mb[1] = *QLBoardTbl[ha->devnum].fwstart;  
2874             qla1280_mailbox_command(ha, BIT_1|BIT_0, &mb[0]);
2875         }
2876         else
2877             printk("qla1280_setup_chip: Failed checksum.\n");
2878     }
2879
2880         KMFREE(tbuf,8000);
2881
2882 #if defined(QL_DEBUG_LEVEL_2) || defined(QL_DEBUG_LEVEL_3)
2883     if (status)
2884         qla1280_print("qla1280_setup_chip: **** FAILED ****\n\r");
2885 #endif
2886 #ifdef QL_DEBUG_LEVEL_3
2887     else
2888         LEAVE("qla1280_setup_chip");
2889 #endif
2890     return(status);
2891 }